"""Fluent solver TUI commands"""
#
# This is an auto-generated file.  DO NOT EDIT!
#
# pylint: disable=line-too-long

from ansys.fluent.core.services.datamodel_tui import PyMenu, TUIMenu, TUIMethod



class main_menu(TUIMenu):
    """
    Fluent solver main menu.
    """
    def __init__(self, service, version, mode, path):
        self.adjoint = self.__class__.adjoint(service, version, mode, path + ["adjoint"])
        self.define = self.__class__.define(service, version, mode, path + ["define"])
        self.display = self.__class__.display(service, version, mode, path + ["display"])
        self.file = self.__class__.file(service, version, mode, path + ["file"])
        self.icing = self.__class__.icing(service, version, mode, path + ["icing"])
        self.mesh = self.__class__.mesh(service, version, mode, path + ["mesh"])
        self.parallel = self.__class__.parallel(service, version, mode, path + ["parallel"])
        self.parameters = self.__class__.parameters(service, version, mode, path + ["parameters"])
        self.parametric_study = self.__class__.parametric_study(service, version, mode, path + ["parametric_study"])
        self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
        self.preferences = self.__class__.preferences(service, version, mode, path + ["preferences"])
        self.report = self.__class__.report(service, version, mode, path + ["report"])
        self.results = self.__class__.results(service, version, mode, path + ["results"])
        self.server = self.__class__.server(service, version, mode, path + ["server"])
        self.setup = self.__class__.setup(service, version, mode, path + ["setup"])
        self.solution = self.__class__.solution(service, version, mode, path + ["solution"])
        self.solve = self.__class__.solve(service, version, mode, path + ["solve"])
        self.surface = self.__class__.surface(service, version, mode, path + ["surface"])
        self.transient_post_processing = self.__class__.transient_post_processing(service, version, mode, path + ["transient_post_processing"])
        self.turbo_post = self.__class__.turbo_post(service, version, mode, path + ["turbo_post"])
        self.turbo_workflow = self.__class__.turbo_workflow(service, version, mode, path + ["turbo_workflow"])
        self.views = self.__class__.views(service, version, mode, path + ["views"])
        self.close_fluent = self.__class__.close_fluent(service, version, mode, path + ["close_fluent"])
        self.print_license_usage = self.__class__.print_license_usage(service, version, mode, path + ["print_license_usage"])
        self.switch_to_meshing_mode = self.__class__.switch_to_meshing_mode(service, version, mode, path + ["switch_to_meshing_mode"])
        super().__init__(service, version, mode, path)
    class close_fluent(TUIMethod):
        """
        Exit program.
        """
    class print_license_usage(TUIMethod):
        """
        Print license usage information.
        """
    class switch_to_meshing_mode(TUIMethod):
        """
        Switch to meshing mode.
        """

    class adjoint(TUIMenu):
        """
        Adjoint.
        """
        def __init__(self, service, version, mode, path):
            self.controls = self.__class__.controls(service, version, mode, path + ["controls"])
            self.design_tool = self.__class__.design_tool(service, version, mode, path + ["design_tool"])
            self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
            self.geometry = self.__class__.geometry(service, version, mode, path + ["geometry"])
            self.methods = self.__class__.methods(service, version, mode, path + ["methods"])
            self.monitors = self.__class__.monitors(service, version, mode, path + ["monitors"])
            self.morphing = self.__class__.morphing(service, version, mode, path + ["morphing"])
            self.multi_objective = self.__class__.multi_objective(service, version, mode, path + ["multi_objective"])
            self.observable = self.__class__.observable(service, version, mode, path + ["observable"])
            self.optimizer = self.__class__.optimizer(service, version, mode, path + ["optimizer"])
            self.postprocess_options = self.__class__.postprocess_options(service, version, mode, path + ["postprocess_options"])
            self.reporting = self.__class__.reporting(service, version, mode, path + ["reporting"])
            self.run = self.__class__.run(service, version, mode, path + ["run"])
            self.utilities = self.__class__.utilities(service, version, mode, path + ["utilities"])
            super().__init__(service, version, mode, path)
        class controls(TUIMethod):
            """
            Controls menu.
            """
        class design_tool(TUIMethod):
            """
            Design tool menu.
            """
        class expert(TUIMethod):
            """
            Expert menu.
            """
        class geometry(TUIMethod):
            """
            Geometry menu.
            """
        class methods(TUIMethod):
            """
            Methods menu.
            """
        class monitors(TUIMethod):
            """
            Monitors menu.
            """
        class morphing(TUIMethod):
            """
            Morphing menu.
            """
        class multi_objective(TUIMethod):
            """
            Multi-Objective menu.
            """
        class observable(TUIMethod):
            """
            Observable menu.
            """
        class optimizer(TUIMethod):
            """
            Optimizer menu.
            """
        class postprocess_options(TUIMethod):
            """
            Postprocess options.
            """
        class reporting(TUIMethod):
            """
            Reporting.
            """
        class run(TUIMethod):
            """
            Run menu.
            """
        class utilities(TUIMethod):
            """
            Utilities menu.
            """

    class define(TUIMenu):
        """
        Enter the define menu.
        """
        def __init__(self, service, version, mode, path):
            self.boundary_conditions = self.__class__.boundary_conditions(service, version, mode, path + ["boundary_conditions"])
            self.curvilinear_coordinate_system = self.__class__.curvilinear_coordinate_system(service, version, mode, path + ["curvilinear_coordinate_system"])
            self.custom_field_functions = self.__class__.custom_field_functions(service, version, mode, path + ["custom_field_functions"])
            self.dynamic_mesh = self.__class__.dynamic_mesh(service, version, mode, path + ["dynamic_mesh"])
            self.gap_model = self.__class__.gap_model(service, version, mode, path + ["gap_model"])
            self.materials = self.__class__.materials(service, version, mode, path + ["materials"])
            self.mesh_interfaces = self.__class__.mesh_interfaces(service, version, mode, path + ["mesh_interfaces"])
            self.mixing_planes = self.__class__.mixing_planes(service, version, mode, path + ["mixing_planes"])
            self.models = self.__class__.models(service, version, mode, path + ["models"])
            self.motion_definitions = self.__class__.motion_definitions(service, version, mode, path + ["motion_definitions"])
            self.named_expressions = self.__class__.named_expressions(service, version, mode, path + ["named_expressions"])
            self.operating_conditions = self.__class__.operating_conditions(service, version, mode, path + ["operating_conditions"])
            self.overset_interfaces = self.__class__.overset_interfaces(service, version, mode, path + ["overset_interfaces"])
            self.parameters = self.__class__.parameters(service, version, mode, path + ["parameters"])
            self.periodic_conditions = self.__class__.periodic_conditions(service, version, mode, path + ["periodic_conditions"])
            self.phases = self.__class__.phases(service, version, mode, path + ["phases"])
            self.profiles = self.__class__.profiles(service, version, mode, path + ["profiles"])
            self.reference_frames = self.__class__.reference_frames(service, version, mode, path + ["reference_frames"])
            self.solution_strategy = self.__class__.solution_strategy(service, version, mode, path + ["solution_strategy"])
            self.spectral = self.__class__.spectral(service, version, mode, path + ["spectral"])
            self.turbo_model = self.__class__.turbo_model(service, version, mode, path + ["turbo_model"])
            self.user_defined = self.__class__.user_defined(service, version, mode, path + ["user_defined"])
            self.virtual_boundary = self.__class__.virtual_boundary(service, version, mode, path + ["virtual_boundary"])
            self.beta_feature_access = self.__class__.beta_feature_access(service, version, mode, path + ["beta_feature_access"])
            self.enable_expressions = self.__class__.enable_expressions(service, version, mode, path + ["enable_expressions"])
            self.enable_mesh_morpher_optimizer = self.__class__.enable_mesh_morpher_optimizer(service, version, mode, path + ["enable_mesh_morpher_optimizer"])
            self.geometry = self.__class__.geometry(service, version, mode, path + ["geometry"])
            self.injections = self.__class__.injections(service, version, mode, path + ["injections"])
            self.physics = self.__class__.physics(service, version, mode, path + ["physics"])
            self.set_unit_system = self.__class__.set_unit_system(service, version, mode, path + ["set_unit_system"])
            self.units = self.__class__.units(service, version, mode, path + ["units"])
            super().__init__(service, version, mode, path)
        class boundary_conditions(TUIMethod):
            """
            Enter the boundary conditions menu.
            """
        class beta_feature_access(TUIMethod):
            """
            .
            """
        class enable_expressions(TUIMethod):
            """
            Enable the expressions feature.
            """
        class enable_mesh_morpher_optimizer(TUIMethod):
            """
            Enable use of mesh morpher/optimizer.
            """
        class geometry(TUIMethod):
            """
            Enter Geometry menu.
            """
        class injections(TUIMethod):
            """
            Enter the injections menu.
            """
        class physics(TUIMethod):
            """
            Manage Physics-regions.
            """
        class set_unit_system(TUIMethod):
            """
            To apply standard set of units to all quantities.
            """
        class units(TUIMethod):
            """
            Set unit conversion factors.
            """

        class curvilinear_coordinate_system(TUIMenu):
            """
            Curvilinear Coordinate System.
            """
            def __init__(self, service, version, mode, path):
                self.calculation_settings = self.__class__.calculation_settings(service, version, mode, path + ["calculation_settings"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.display_settings = self.__class__.display_settings(service, version, mode, path + ["display_settings"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.new = self.__class__.new(service, version, mode, path + ["new"])
                super().__init__(service, version, mode, path)
            class calculation_settings(TUIMethod):
                """
                Define Settings for curvilinear coordinate system.
                """
            class delete(TUIMethod):
                """
                Delete Curvilinear Coordinate System.
                """
            class display(TUIMethod):
                """
                Display Curvilinear Coordinate System.
                """
            class display_settings(TUIMethod):
                """
                Display settings for Curvilinear Coordinate System.
                """
            class edit(TUIMethod):
                """
                Edit an existing curvilinear coordinate system.
                """
            class new(TUIMethod):
                """
                Define a new curvilinear coordinate system.
                """

        class custom_field_functions(TUIMenu):
            """
            Enter the custom field functions menu.
            """
            def __init__(self, service, version, mode, path):
                self.define = self.__class__.define(service, version, mode, path + ["define"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.example_cff_definitions = self.__class__.example_cff_definitions(service, version, mode, path + ["example_cff_definitions"])
                self.list_valid_cell_function_names = self.__class__.list_valid_cell_function_names(service, version, mode, path + ["list_valid_cell_function_names"])
                self.load = self.__class__.load(service, version, mode, path + ["load"])
                self.save = self.__class__.save(service, version, mode, path + ["save"])
                super().__init__(service, version, mode, path)
            class define(TUIMethod):
                """
                Define a custom field function.
                """
            class delete(TUIMethod):
                """
                Delete a custom field function.
                """
            class example_cff_definitions(TUIMethod):
                """
                List example custom field functions.
                """
            class list_valid_cell_function_names(TUIMethod):
                """
                .
                """
            class load(TUIMethod):
                """
                .
                """
            class save(TUIMethod):
                """
                .
                """

        class dynamic_mesh(TUIMenu):
            """
            Enter the dynamic mesh menu.
            """
            def __init__(self, service, version, mode, path):
                self.actions = self.__class__.actions(service, version, mode, path + ["actions"])
                self.controls = self.__class__.controls(service, version, mode, path + ["controls"])
                self.events = self.__class__.events(service, version, mode, path + ["events"])
                self.transient_settings = self.__class__.transient_settings(service, version, mode, path + ["transient_settings"])
                self.zones = self.__class__.zones(service, version, mode, path + ["zones"])
                self.dynamic_mesh = self.__class__.dynamic_mesh(service, version, mode, path + ["dynamic_mesh"])
                super().__init__(service, version, mode, path)
            class dynamic_mesh(TUIMethod):
                """
                Enable/disable the dynamic mesh solver and options.
                """

            class actions(TUIMenu):
                """
                Enter the dynamic mesh actions menu.
                """
                def __init__(self, service, version, mode, path):
                    self.remesh_cell_zone = self.__class__.remesh_cell_zone(service, version, mode, path + ["remesh_cell_zone"])
                    super().__init__(service, version, mode, path)
                class remesh_cell_zone(TUIMethod):
                    """
                    Manually remesh cell zone with option to remesh adjacent dynamic face zones.
                    """

            class controls(TUIMenu):
                """
                Enter the dynamic mesh control menu.
                """
                def __init__(self, service, version, mode, path):
                    self.contact_parameters = self.__class__.contact_parameters(service, version, mode, path + ["contact_parameters"])
                    self.implicit_update_parameters = self.__class__.implicit_update_parameters(service, version, mode, path + ["implicit_update_parameters"])
                    self.in_cylinder_parameters = self.__class__.in_cylinder_parameters(service, version, mode, path + ["in_cylinder_parameters"])
                    self.layering_parameters = self.__class__.layering_parameters(service, version, mode, path + ["layering_parameters"])
                    self.periodic_displacement_parameters = self.__class__.periodic_displacement_parameters(service, version, mode, path + ["periodic_displacement_parameters"])
                    self.remeshing_parameters = self.__class__.remeshing_parameters(service, version, mode, path + ["remeshing_parameters"])
                    self.six_dof_parameters = self.__class__.six_dof_parameters(service, version, mode, path + ["six_dof_parameters"])
                    self.smoothing_parameters = self.__class__.smoothing_parameters(service, version, mode, path + ["smoothing_parameters"])
                    self.in_cylinder_output = self.__class__.in_cylinder_output(service, version, mode, path + ["in_cylinder_output"])
                    self.layering = self.__class__.layering(service, version, mode, path + ["layering"])
                    self.remeshing = self.__class__.remeshing(service, version, mode, path + ["remeshing"])
                    self.smoothing = self.__class__.smoothing(service, version, mode, path + ["smoothing"])
                    self.steady_pseudo_time_control = self.__class__.steady_pseudo_time_control(service, version, mode, path + ["steady_pseudo_time_control"])
                    super().__init__(service, version, mode, path)
                class in_cylinder_output(TUIMethod):
                    """
                    Enable/disable in-cylinder output.
                    """
                class layering(TUIMethod):
                    """
                    .
                    """
                class remeshing(TUIMethod):
                    """
                    .
                    """
                class smoothing(TUIMethod):
                    """
                    .
                    """
                class steady_pseudo_time_control(TUIMethod):
                    """
                    Enable/disable pseudo time step control in user interface.
                    """

                class contact_parameters(TUIMenu):
                    """
                    Enter the dynamic mesh contact detection menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.flow_control_parameters = self.__class__.flow_control_parameters(service, version, mode, path + ["flow_control_parameters"])
                        self.contact_face_zones = self.__class__.contact_face_zones(service, version, mode, path + ["contact_face_zones"])
                        self.contact_method = self.__class__.contact_method(service, version, mode, path + ["contact_method"])
                        self.contact_threshold = self.__class__.contact_threshold(service, version, mode, path + ["contact_threshold"])
                        self.contact_udf = self.__class__.contact_udf(service, version, mode, path + ["contact_udf"])
                        self.flow_control = self.__class__.flow_control(service, version, mode, path + ["flow_control"])
                        self.render_contact_cells = self.__class__.render_contact_cells(service, version, mode, path + ["render_contact_cells"])
                        self.update_contact_marks = self.__class__.update_contact_marks(service, version, mode, path + ["update_contact_marks"])
                        self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                        super().__init__(service, version, mode, path)
                    class contact_face_zones(TUIMethod):
                        """
                        Select face zones involved in contact detection.
                        """
                    class contact_method(TUIMethod):
                        """
                        Select the method used for flow control in the contact region.
                        """
                    class contact_threshold(TUIMethod):
                        """
                        Specify threshold distance for contact detection.
                        """
                    class contact_udf(TUIMethod):
                        """
                        Select UDF to be invoked when contact is detected.
                        """
                    class flow_control(TUIMethod):
                        """
                        Enable/disable flow control.
                        """
                    class render_contact_cells(TUIMethod):
                        """
                        Set the option to include contact-cells in post-processing.
                        """
                    class update_contact_marks(TUIMethod):
                        """
                        Update which cells are marked in order to block flow in the contact region.
                        """
                    class verbosity(TUIMethod):
                        """
                        Set the verbosity for contact-detection.
                        """

                    class flow_control_parameters(TUIMenu):
                        """
                        Enter the flow control menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.create_flow_control_zone = self.__class__.create_flow_control_zone(service, version, mode, path + ["create_flow_control_zone"])
                            self.delete_flow_control_zone = self.__class__.delete_flow_control_zone(service, version, mode, path + ["delete_flow_control_zone"])
                            self.solution_stabilization = self.__class__.solution_stabilization(service, version, mode, path + ["solution_stabilization"])
                            super().__init__(service, version, mode, path)
                        class create_flow_control_zone(TUIMethod):
                            """
                            Create a flow control zone.
                            """
                        class delete_flow_control_zone(TUIMethod):
                            """
                            Delete a flow control zone.
                            """
                        class solution_stabilization(TUIMethod):
                            """
                            Enable/disable the performance of additional iterations per time step and
                            the application of solution controls to improve the stability of the solver.
                            """

                class implicit_update_parameters(TUIMenu):
                    """
                    Enter the dynamic mesh implicit update menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.motion_relaxation = self.__class__.motion_relaxation(service, version, mode, path + ["motion_relaxation"])
                        self.residual_criteria = self.__class__.residual_criteria(service, version, mode, path + ["residual_criteria"])
                        self.update_interval = self.__class__.update_interval(service, version, mode, path + ["update_interval"])
                        super().__init__(service, version, mode, path)
                    class motion_relaxation(TUIMethod):
                        """
                        Specify motion relaxation of implicit update.
                        """
                    class residual_criteria(TUIMethod):
                        """
                        Specify residual criteria of implicit update.
                        """
                    class update_interval(TUIMethod):
                        """
                        Specify update interval of implicit update.
                        """

                class in_cylinder_parameters(TUIMenu):
                    """
                    Enter the dynamic mesh in-cylinder menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.crank_angle_step = self.__class__.crank_angle_step(service, version, mode, path + ["crank_angle_step"])
                        self.crank_period = self.__class__.crank_period(service, version, mode, path + ["crank_period"])
                        self.max_crank_angle_step = self.__class__.max_crank_angle_step(service, version, mode, path + ["max_crank_angle_step"])
                        self.minimum_lift = self.__class__.minimum_lift(service, version, mode, path + ["minimum_lift"])
                        self.modify_lift = self.__class__.modify_lift(service, version, mode, path + ["modify_lift"])
                        self.piston_data = self.__class__.piston_data(service, version, mode, path + ["piston_data"])
                        self.piston_stroke_cutoff = self.__class__.piston_stroke_cutoff(service, version, mode, path + ["piston_stroke_cutoff"])
                        self.position_starting_mesh = self.__class__.position_starting_mesh(service, version, mode, path + ["position_starting_mesh"])
                        self.print_plot_lift = self.__class__.print_plot_lift(service, version, mode, path + ["print_plot_lift"])
                        self.starting_crank_angle = self.__class__.starting_crank_angle(service, version, mode, path + ["starting_crank_angle"])
                        super().__init__(service, version, mode, path)
                    class crank_angle_step(TUIMethod):
                        """
                        Specify the crank angle step size.
                        """
                    class crank_period(TUIMethod):
                        """
                        Specify the crank period.
                        """
                    class max_crank_angle_step(TUIMethod):
                        """
                        Specify the maximum crank angle step size.
                        """
                    class minimum_lift(TUIMethod):
                        """
                        Specify the minimum lift for in-cylinder valves.
                        """
                    class modify_lift(TUIMethod):
                        """
                        Modify the lift curve (shift or scale).
                        """
                    class piston_data(TUIMethod):
                        """
                        Specify the crank radius, connecting rod length, and piston pin offset.
                        """
                    class piston_stroke_cutoff(TUIMethod):
                        """
                        Specify the cut off point for in-cylinder piston.
                        """
                    class position_starting_mesh(TUIMethod):
                        """
                        Move mesh from top dead center to starting crank angle.
                        """
                    class print_plot_lift(TUIMethod):
                        """
                        Print or plot valve lift curve.
                        """
                    class starting_crank_angle(TUIMethod):
                        """
                        Specify the starting crank angle.
                        """

                class layering_parameters(TUIMenu):
                    """
                    Enter the dynamic mesh layering menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.collapse_factor = self.__class__.collapse_factor(service, version, mode, path + ["collapse_factor"])
                        self.constant_height = self.__class__.constant_height(service, version, mode, path + ["constant_height"])
                        self.split_factor = self.__class__.split_factor(service, version, mode, path + ["split_factor"])
                        super().__init__(service, version, mode, path)
                    class collapse_factor(TUIMethod):
                        """
                        .
                        """
                    class constant_height(TUIMethod):
                        """
                        .
                        """
                    class split_factor(TUIMethod):
                        """
                        .
                        """

                class periodic_displacement_parameters(TUIMenu):
                    """
                    Enter the dynamic mesh periodic displacement menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.copy_displacement = self.__class__.copy_displacement(service, version, mode, path + ["copy_displacement"])
                        self.create_displacement = self.__class__.create_displacement(service, version, mode, path + ["create_displacement"])
                        self.create_group = self.__class__.create_group(service, version, mode, path + ["create_group"])
                        self.delete_all_displacements = self.__class__.delete_all_displacements(service, version, mode, path + ["delete_all_displacements"])
                        self.delete_all_groups = self.__class__.delete_all_groups(service, version, mode, path + ["delete_all_groups"])
                        self.delete_displacement = self.__class__.delete_displacement(service, version, mode, path + ["delete_displacement"])
                        self.delete_group = self.__class__.delete_group(service, version, mode, path + ["delete_group"])
                        self.edit_displacement = self.__class__.edit_displacement(service, version, mode, path + ["edit_displacement"])
                        self.edit_group = self.__class__.edit_group(service, version, mode, path + ["edit_group"])
                        self.fast_mesh_smoothing = self.__class__.fast_mesh_smoothing(service, version, mode, path + ["fast_mesh_smoothing"])
                        self.list_displacements = self.__class__.list_displacements(service, version, mode, path + ["list_displacements"])
                        self.list_groups = self.__class__.list_groups(service, version, mode, path + ["list_groups"])
                        self.set_active_displacement = self.__class__.set_active_displacement(service, version, mode, path + ["set_active_displacement"])
                        super().__init__(service, version, mode, path)
                    class copy_displacement(TUIMethod):
                        """
                        Copy Periodic Displacement.
                        """
                    class create_displacement(TUIMethod):
                        """
                        Create Periodic Displacement.
                        """
                    class create_group(TUIMethod):
                        """
                        Create Periodic Displacement Group.
                        """
                    class delete_all_displacements(TUIMethod):
                        """
                        Delete All Periodic Displacements.
                        """
                    class delete_all_groups(TUIMethod):
                        """
                        Delete All Periodic Displacement Groups.
                        """
                    class delete_displacement(TUIMethod):
                        """
                        Delete Periodic Displacement.
                        """
                    class delete_group(TUIMethod):
                        """
                        Delete Periodic Displacement Group.
                        """
                    class edit_displacement(TUIMethod):
                        """
                        Edit Periodic Displacement.
                        """
                    class edit_group(TUIMethod):
                        """
                        Edit Periodic Displacement Group.
                        """
                    class fast_mesh_smoothing(TUIMethod):
                        """
                        Enable/disable Fast Mesh Smoothing.
                        """
                    class list_displacements(TUIMethod):
                        """
                        List Periodic Displacements.
                        """
                    class list_groups(TUIMethod):
                        """
                        List Periodic Displacement Groups.
                        """
                    class set_active_displacement(TUIMethod):
                        """
                        Set Active Periodic Displacement in Group.
                        """

                class remeshing_parameters(TUIMenu):
                    """
                    Enter the dynamic mesh remeshing menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.prism_controls = self.__class__.prism_controls(service, version, mode, path + ["prism_controls"])
                        self.prism_layer_parameters = self.__class__.prism_layer_parameters(service, version, mode, path + ["prism_layer_parameters"])
                        self.sizing_controls = self.__class__.sizing_controls(service, version, mode, path + ["sizing_controls"])
                        self.cell_skew_max = self.__class__.cell_skew_max(service, version, mode, path + ["cell_skew_max"])
                        self.face_skew_max = self.__class__.face_skew_max(service, version, mode, path + ["face_skew_max"])
                        self.length_max = self.__class__.length_max(service, version, mode, path + ["length_max"])
                        self.length_min = self.__class__.length_min(service, version, mode, path + ["length_min"])
                        self.parallel_remeshing = self.__class__.parallel_remeshing(service, version, mode, path + ["parallel_remeshing"])
                        self.poly_remeshing = self.__class__.poly_remeshing(service, version, mode, path + ["poly_remeshing"])
                        self.remeshing_after_moving = self.__class__.remeshing_after_moving(service, version, mode, path + ["remeshing_after_moving"])
                        self.remeshing_methods = self.__class__.remeshing_methods(service, version, mode, path + ["remeshing_methods"])
                        self.retain_size_distribution = self.__class__.retain_size_distribution(service, version, mode, path + ["retain_size_distribution"])
                        self.size_remesh_interval = self.__class__.size_remesh_interval(service, version, mode, path + ["size_remesh_interval"])
                        self.sizing_funct_defaults = self.__class__.sizing_funct_defaults(service, version, mode, path + ["sizing_funct_defaults"])
                        self.sizing_funct_rate = self.__class__.sizing_funct_rate(service, version, mode, path + ["sizing_funct_rate"])
                        self.sizing_funct_resolution = self.__class__.sizing_funct_resolution(service, version, mode, path + ["sizing_funct_resolution"])
                        self.sizing_funct_variation = self.__class__.sizing_funct_variation(service, version, mode, path + ["sizing_funct_variation"])
                        self.sizing_function = self.__class__.sizing_function(service, version, mode, path + ["sizing_function"])
                        self.unified_remeshing = self.__class__.unified_remeshing(service, version, mode, path + ["unified_remeshing"])
                        self.zone_remeshing = self.__class__.zone_remeshing(service, version, mode, path + ["zone_remeshing"])
                        super().__init__(service, version, mode, path)
                    class cell_skew_max(TUIMethod):
                        """
                        .
                        """
                    class face_skew_max(TUIMethod):
                        """
                        .
                        """
                    class length_max(TUIMethod):
                        """
                        .
                        """
                    class length_min(TUIMethod):
                        """
                        .
                        """
                    class parallel_remeshing(TUIMethod):
                        """
                        Enable/disable parallel remeshing for zone remeshing.
                        """
                    class poly_remeshing(TUIMethod):
                        """
                        Enable/disable poly remeshing.
                        """
                    class remeshing_after_moving(TUIMethod):
                        """
                        Enable/disable optional remeshing after mesh motion to meet skewness threshold.
                        Steady state dynamic mesh only.
                        """
                    class remeshing_methods(TUIMethod):
                        """
                        Enable/disable remeshing methods.
                        """
                    class retain_size_distribution(TUIMethod):
                        """
                        .
                        """
                    class size_remesh_interval(TUIMethod):
                        """
                        Set the interval (in time steps) when remeshing based on size is done.
                        """
                    class sizing_funct_defaults(TUIMethod):
                        """
                        Set sizing function defaults.
                        """
                    class sizing_funct_rate(TUIMethod):
                        """
                        Determine how far from the boundary the increase/decrease happens.
                        """
                    class sizing_funct_resolution(TUIMethod):
                        """
                        Set the sizing function resolution with respect to shortest boundary.
                        """
                    class sizing_funct_variation(TUIMethod):
                        """
                        Set the maximum sizing function increase/decrease in the interior.
                        """
                    class sizing_function(TUIMethod):
                        """
                        Enable/disable sizing function to control size based remeshing.
                        """
                    class unified_remeshing(TUIMethod):
                        """
                        .
                        """
                    class zone_remeshing(TUIMethod):
                        """
                        Enable/disable cell zone remeshing method.
                        """

                    class prism_controls(TUIMenu):
                        """
                        Specify optional prism controls.
                        """
                        def __init__(self, service, version, mode, path):
                            self.add = self.__class__.add(service, version, mode, path + ["add"])
                            self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            super().__init__(service, version, mode, path)
                        class add(TUIMethod):
                            """
                            Add a new object.
                            """
                        class delete(TUIMethod):
                            """
                            Delete an object.
                            """
                        class edit(TUIMethod):
                            """
                            Edit an object.
                            """
                        class list(TUIMethod):
                            """
                            List objects.
                            """
                        class list_properties(TUIMethod):
                            """
                            List properties of an object.
                            """

                    class prism_layer_parameters(TUIMenu):
                        """
                        Enter the dynamic mesh prism remeshing menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.first_height = self.__class__.first_height(service, version, mode, path + ["first_height"])
                            self.growth_rate = self.__class__.growth_rate(service, version, mode, path + ["growth_rate"])
                            self.number_of_layers = self.__class__.number_of_layers(service, version, mode, path + ["number_of_layers"])
                            super().__init__(service, version, mode, path)
                        class first_height(TUIMethod):
                            """
                            Set first cell height in the prism layer.
                            """
                        class growth_rate(TUIMethod):
                            """
                            Set the geometric growth rate of the prism layer.
                            """
                        class number_of_layers(TUIMethod):
                            """
                            Set the number of elements in the prism layer.
                            """

                    class sizing_controls(TUIMenu):
                        """
                        Specify optional sizing controls.
                        """
                        def __init__(self, service, version, mode, path):
                            self.add = self.__class__.add(service, version, mode, path + ["add"])
                            self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            super().__init__(service, version, mode, path)
                        class add(TUIMethod):
                            """
                            Add a new object.
                            """
                        class delete(TUIMethod):
                            """
                            Delete an object.
                            """
                        class edit(TUIMethod):
                            """
                            Edit an object.
                            """
                        class list(TUIMethod):
                            """
                            List objects.
                            """
                        class list_properties(TUIMethod):
                            """
                            List properties of an object.
                            """

                class six_dof_parameters(TUIMenu):
                    """
                    Enter the dynamic mesh six-dof menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.create_properties = self.__class__.create_properties(service, version, mode, path + ["create_properties"])
                        self.delete_properties = self.__class__.delete_properties(service, version, mode, path + ["delete_properties"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.motion_history = self.__class__.motion_history(service, version, mode, path + ["motion_history"])
                        self.motion_history_file_name = self.__class__.motion_history_file_name(service, version, mode, path + ["motion_history_file_name"])
                        self.second_order = self.__class__.second_order(service, version, mode, path + ["second_order"])
                        self.x_component_of_gravity = self.__class__.x_component_of_gravity(service, version, mode, path + ["x_component_of_gravity"])
                        self.y_component_of_gravity = self.__class__.y_component_of_gravity(service, version, mode, path + ["y_component_of_gravity"])
                        self.z_component_of_gravity = self.__class__.z_component_of_gravity(service, version, mode, path + ["z_component_of_gravity"])
                        super().__init__(service, version, mode, path)
                    class create_properties(TUIMethod):
                        """
                        Create a set of Six DOF Properties.
                        """
                    class delete_properties(TUIMethod):
                        """
                        Delete a set of Six DOF Properties.
                        """
                    class list_properties(TUIMethod):
                        """
                        List Six DOF Properties.
                        """
                    class motion_history(TUIMethod):
                        """
                        Enable/disable writing position/orientation of six DOF zones to file.
                        """
                    class motion_history_file_name(TUIMethod):
                        """
                        Location of six DOF motion history file.
                        """
                    class second_order(TUIMethod):
                        """
                        Enable/disable second order six DOF solver.
                        """
                    class x_component_of_gravity(TUIMethod):
                        """
                        Specify x-component-of-gravity.
                        """
                    class y_component_of_gravity(TUIMethod):
                        """
                        Specify y-component-of-gravity.
                        """
                    class z_component_of_gravity(TUIMethod):
                        """
                        Specify z-component-of-gravity.
                        """

                class smoothing_parameters(TUIMenu):
                    """
                    Enter the dynamic mesh smoothing menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.amg_stabilization = self.__class__.amg_stabilization(service, version, mode, path + ["amg_stabilization"])
                        self.bnd_node_relaxation = self.__class__.bnd_node_relaxation(service, version, mode, path + ["bnd_node_relaxation"])
                        self.bnd_stiffness_factor = self.__class__.bnd_stiffness_factor(service, version, mode, path + ["bnd_stiffness_factor"])
                        self.boundary_distance_method = self.__class__.boundary_distance_method(service, version, mode, path + ["boundary_distance_method"])
                        self.constant_factor = self.__class__.constant_factor(service, version, mode, path + ["constant_factor"])
                        self.convergence_tolerance = self.__class__.convergence_tolerance(service, version, mode, path + ["convergence_tolerance"])
                        self.diffusion_coeff_function = self.__class__.diffusion_coeff_function(service, version, mode, path + ["diffusion_coeff_function"])
                        self.diffusion_coeff_parameter = self.__class__.diffusion_coeff_parameter(service, version, mode, path + ["diffusion_coeff_parameter"])
                        self.diffusion_fvm = self.__class__.diffusion_fvm(service, version, mode, path + ["diffusion_fvm"])
                        self.laplace_node_relaxation = self.__class__.laplace_node_relaxation(service, version, mode, path + ["laplace_node_relaxation"])
                        self.local_smoothing = self.__class__.local_smoothing(service, version, mode, path + ["local_smoothing"])
                        self.max_iter = self.__class__.max_iter(service, version, mode, path + ["max_iter"])
                        self.number_local_layers = self.__class__.number_local_layers(service, version, mode, path + ["number_local_layers"])
                        self.poisson_ratio = self.__class__.poisson_ratio(service, version, mode, path + ["poisson_ratio"])
                        self.relative_convergence_tolerance = self.__class__.relative_convergence_tolerance(service, version, mode, path + ["relative_convergence_tolerance"])
                        self.skew_smooth_all_deforming_boundaries = self.__class__.skew_smooth_all_deforming_boundaries(service, version, mode, path + ["skew_smooth_all_deforming_boundaries"])
                        self.skew_smooth_cell_skew_max = self.__class__.skew_smooth_cell_skew_max(service, version, mode, path + ["skew_smooth_cell_skew_max"])
                        self.skew_smooth_face_skew_max = self.__class__.skew_smooth_face_skew_max(service, version, mode, path + ["skew_smooth_face_skew_max"])
                        self.skew_smooth_niter = self.__class__.skew_smooth_niter(service, version, mode, path + ["skew_smooth_niter"])
                        self.smooth_boundary_layers_with_adjacent_zone = self.__class__.smooth_boundary_layers_with_adjacent_zone(service, version, mode, path + ["smooth_boundary_layers_with_adjacent_zone"])
                        self.smooth_from_reference_position = self.__class__.smooth_from_reference_position(service, version, mode, path + ["smooth_from_reference_position"])
                        self.smoothing_method = self.__class__.smoothing_method(service, version, mode, path + ["smoothing_method"])
                        self.spring_on_all_elements = self.__class__.spring_on_all_elements(service, version, mode, path + ["spring_on_all_elements"])
                        self.spring_on_simplex_elements = self.__class__.spring_on_simplex_elements(service, version, mode, path + ["spring_on_simplex_elements"])
                        self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                        super().__init__(service, version, mode, path)
                    class amg_stabilization(TUIMethod):
                        """
                        .
                        """
                    class bnd_node_relaxation(TUIMethod):
                        """
                        .
                        """
                    class bnd_stiffness_factor(TUIMethod):
                        """
                        .
                        """
                    class boundary_distance_method(TUIMethod):
                        """
                        .
                        """
                    class constant_factor(TUIMethod):
                        """
                        .
                        """
                    class convergence_tolerance(TUIMethod):
                        """
                        .
                        """
                    class diffusion_coeff_function(TUIMethod):
                        """
                        .
                        """
                    class diffusion_coeff_parameter(TUIMethod):
                        """
                        .
                        """
                    class diffusion_fvm(TUIMethod):
                        """
                        .
                        """
                    class laplace_node_relaxation(TUIMethod):
                        """
                        .
                        """
                    class local_smoothing(TUIMethod):
                        """
                        .
                        """
                    class max_iter(TUIMethod):
                        """
                        .
                        """
                    class number_local_layers(TUIMethod):
                        """
                        .
                        """
                    class poisson_ratio(TUIMethod):
                        """
                        .
                        """
                    class relative_convergence_tolerance(TUIMethod):
                        """
                        .
                        """
                    class skew_smooth_all_deforming_boundaries(TUIMethod):
                        """
                        .
                        """
                    class skew_smooth_cell_skew_max(TUIMethod):
                        """
                        .
                        """
                    class skew_smooth_face_skew_max(TUIMethod):
                        """
                        .
                        """
                    class skew_smooth_niter(TUIMethod):
                        """
                        .
                        """
                    class smooth_boundary_layers_with_adjacent_zone(TUIMethod):
                        """
                        .
                        """
                    class smooth_from_reference_position(TUIMethod):
                        """
                        .
                        """
                    class smoothing_method(TUIMethod):
                        """
                        .
                        """
                    class spring_on_all_elements(TUIMethod):
                        """
                        .
                        """
                    class spring_on_simplex_elements(TUIMethod):
                        """
                        .
                        """
                    class verbosity(TUIMethod):
                        """
                        .
                        """

            class events(TUIMenu):
                """
                Enter the dynamic mesh events menu.
                """
                def __init__(self, service, version, mode, path):
                    self.export_event_file = self.__class__.export_event_file(service, version, mode, path + ["export_event_file"])
                    self.import_event_file = self.__class__.import_event_file(service, version, mode, path + ["import_event_file"])
                    super().__init__(service, version, mode, path)
                class export_event_file(TUIMethod):
                    """
                    Export dynamic mesh events to file.
                    """
                class import_event_file(TUIMethod):
                    """
                    Import dynamic mesh event file.
                    """

            class transient_settings(TUIMenu):
                """
                Enter the dynamic mesh transient settings menu.
                """
                def __init__(self, service, version, mode, path):
                    self.allow_second_order = self.__class__.allow_second_order(service, version, mode, path + ["allow_second_order"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class allow_second_order(TUIMethod):
                    """
                    Enable/disable 2nd order transient scheme for dynamic mesh cases.
                    """
                class verbosity(TUIMethod):
                    """
                    Enable/disable transient scheme verbosity for dynamic mesh cases.
                    """

            class zones(TUIMenu):
                """
                Enter the dynamic mesh zones menu.
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.insert_boundary_layer = self.__class__.insert_boundary_layer(service, version, mode, path + ["insert_boundary_layer"])
                    self.insert_interior_layer = self.__class__.insert_interior_layer(service, version, mode, path + ["insert_interior_layer"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.remove_boundary_layer = self.__class__.remove_boundary_layer(service, version, mode, path + ["remove_boundary_layer"])
                    self.remove_interior_layer = self.__class__.remove_interior_layer(service, version, mode, path + ["remove_interior_layer"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    Create dynamic zone.
                    """
                class delete(TUIMethod):
                    """
                    Delete dynamic zone.
                    """
                class insert_boundary_layer(TUIMethod):
                    """
                    Insert new cell zone.
                    """
                class insert_interior_layer(TUIMethod):
                    """
                    Insert new layer cell zone at specified location.
                    """
                class list(TUIMethod):
                    """
                    List dynamic zones.
                    """
                class remove_boundary_layer(TUIMethod):
                    """
                    Remove cell zone.
                    """
                class remove_interior_layer(TUIMethod):
                    """
                    Remove interior layer cell zone.
                    """

        class gap_model(TUIMenu):
            """
            Enter the narrow-gaps menu.
            """
            def __init__(self, service, version, mode, path):
                self.advanced_options = self.__class__.advanced_options(service, version, mode, path + ["advanced_options"])
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                self.list_gap_cell_zones = self.__class__.list_gap_cell_zones(service, version, mode, path + ["list_gap_cell_zones"])
                self.list_gap_face_zones = self.__class__.list_gap_face_zones(service, version, mode, path + ["list_gap_face_zones"])
                self.list_gap_regions = self.__class__.list_gap_regions(service, version, mode, path + ["list_gap_regions"])
                self.render_gap_regions = self.__class__.render_gap_regions(service, version, mode, path + ["render_gap_regions"])
                super().__init__(service, version, mode, path)
            class create(TUIMethod):
                """
                Create a gap object.
                """
            class delete(TUIMethod):
                """
                Delete an exiting gap object.
                """
            class delete_all(TUIMethod):
                """
                Delete all of the exiting gap objects.
                """
            class edit(TUIMethod):
                """
                Edit an exiting gap object.
                """
            class enable(TUIMethod):
                """
                Enable/Disable gap model.
                """
            class list_gap_cell_zones(TUIMethod):
                """
                List name of the gap cells zones that can be used as exclided cell zones in gaps creation.
                """
            class list_gap_face_zones(TUIMethod):
                """
                List name of the gap face zones that can be used for gaps creation.
                """
            class list_gap_regions(TUIMethod):
                """
                List gap regions.
                """
            class render_gap_regions(TUIMethod):
                """
                Update gap regions for postprocessing.
                """

            class advanced_options(TUIMenu):
                """
                Show options.
                """
                def __init__(self, service, version, mode, path):
                    self.alternative_marking = self.__class__.alternative_marking(service, version, mode, path + ["alternative_marking"])
                    self.cell_check_distance_factor = self.__class__.cell_check_distance_factor(service, version, mode, path + ["cell_check_distance_factor"])
                    self.check_cfl_condition = self.__class__.check_cfl_condition(service, version, mode, path + ["check_cfl_condition"])
                    self.clear_gap_regions = self.__class__.clear_gap_regions(service, version, mode, path + ["clear_gap_regions"])
                    self.enhanced_data_interpolation = self.__class__.enhanced_data_interpolation(service, version, mode, path + ["enhanced_data_interpolation"])
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.extend_gap_regions = self.__class__.extend_gap_regions(service, version, mode, path + ["extend_gap_regions"])
                    self.fill_data_in_gap_regions = self.__class__.fill_data_in_gap_regions(service, version, mode, path + ["fill_data_in_gap_regions"])
                    self.flow_blocking_stabilization_parameters = self.__class__.flow_blocking_stabilization_parameters(service, version, mode, path + ["flow_blocking_stabilization_parameters"])
                    self.include_coupled_walls = self.__class__.include_coupled_walls(service, version, mode, path + ["include_coupled_walls"])
                    self.precise_gap_marking = self.__class__.precise_gap_marking(service, version, mode, path + ["precise_gap_marking"])
                    self.reduce_gap_regions = self.__class__.reduce_gap_regions(service, version, mode, path + ["reduce_gap_regions"])
                    self.render_flow_modeling_gaps = self.__class__.render_flow_modeling_gaps(service, version, mode, path + ["render_flow_modeling_gaps"])
                    self.render_gap_interface = self.__class__.render_gap_interface(service, version, mode, path + ["render_gap_interface"])
                    self.revert_controls_to_default = self.__class__.revert_controls_to_default(service, version, mode, path + ["revert_controls_to_default"])
                    self.solution_stabilization = self.__class__.solution_stabilization(service, version, mode, path + ["solution_stabilization"])
                    self.sponge_layer = self.__class__.sponge_layer(service, version, mode, path + ["sponge_layer"])
                    self.update_gap_regions = self.__class__.update_gap_regions(service, version, mode, path + ["update_gap_regions"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class alternative_marking(TUIMethod):
                    """
                    Mark gap regions using an alternative marking algorithm.
                    """
                class cell_check_distance_factor(TUIMethod):
                    """
                    Enter value of the cell distance factor.
                    """
                class check_cfl_condition(TUIMethod):
                    """
                    Check time step size for better convergence.
                    """
                class clear_gap_regions(TUIMethod):
                    """
                    Clear gap model solution information and marks.
                    """
                class enhanced_data_interpolation(TUIMethod):
                    """
                    Use enhanced data interpolation for updating information in gap regions.
                    """
                class expert(TUIMethod):
                    """
                    Enable expert options for gap model.
                    """
                class extend_gap_regions(TUIMethod):
                    """
                    Extend gap regions for better convergence.
                    """
                class fill_data_in_gap_regions(TUIMethod):
                    """
                    Interpolate solution data into the whole gap regions.
                    """
                class flow_blocking_stabilization_parameters(TUIMethod):
                    """
                    Adjust stabilization settings for the sponge layer used for blocked gap regions.
                    """
                class include_coupled_walls(TUIMethod):
                    """
                    Include coupled walls in gap face zones.
                    """
                class precise_gap_marking(TUIMethod):
                    """
                    Mark cells in gap regions using more accurate search algorithm.
                    """
                class reduce_gap_regions(TUIMethod):
                    """
                    Using a more restrictive algorithm for marking cells in gap regions.
                    """
                class render_flow_modeling_gaps(TUIMethod):
                    """
                    Render solution inside flow modeling gap cells.
                    """
                class render_gap_interface(TUIMethod):
                    """
                    Render gap interface.
                    """
                class revert_controls_to_default(TUIMethod):
                    """
                    Revert gap stabilization and any related solver settings to default.
                    """
                class solution_stabilization(TUIMethod):
                    """
                    Set solution stabilization level for gap model.
                    """
                class sponge_layer(TUIMethod):
                    """
                    Set advanced settings for gap sponge layer.
                    """
                class update_gap_regions(TUIMethod):
                    """
                    Update gap regions and gap model solution information.
                    """
                class verbosity(TUIMethod):
                    """
                    Set the verbosity for gap model.
                    """

        class materials(TUIMenu):
            """
            Enter the materials menu.
            """
            def __init__(self, service, version, mode, path):
                self.data_base = self.__class__.data_base(service, version, mode, path + ["data_base"])
                self.change_create = self.__class__.change_create(service, version, mode, path + ["change_create"])
                self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                self.copy_by_formula = self.__class__.copy_by_formula(service, version, mode, path + ["copy_by_formula"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.list_materials = self.__class__.list_materials(service, version, mode, path + ["list_materials"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                super().__init__(service, version, mode, path)
            class change_create(TUIMethod):
                """
                Change the properties of a locally-stored material or create a new material.
                """
            class copy(TUIMethod):
                """
                .
                """
            class copy_by_formula(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                Delete a material from local storage.
                """
            class list_materials(TUIMethod):
                """
                .
                """
            class list_properties(TUIMethod):
                """
                .
                """

            class data_base(TUIMenu):
                """
                Enter the database menu.
                """
                def __init__(self, service, version, mode, path):
                    self.database_type = self.__class__.database_type(service, version, mode, path + ["database_type"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list_materials = self.__class__.list_materials(service, version, mode, path + ["list_materials"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.new = self.__class__.new(service, version, mode, path + ["new"])
                    self.save = self.__class__.save(service, version, mode, path + ["save"])
                    super().__init__(service, version, mode, path)
                class database_type(TUIMethod):
                    """
                    Set the database type.
                    """
                class edit(TUIMethod):
                    """
                    Edit a material.
                    """
                class list_materials(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class new(TUIMethod):
                    """
                    Define a new material.
                    """
                class save(TUIMethod):
                    """
                    Save user-defined database.
                    """

        class mesh_interfaces(TUIMenu):
            """
            Enter the mesh-interfaces menu.
            """
            def __init__(self, service, version, mode, path):
                self.auto_options = self.__class__.auto_options(service, version, mode, path + ["auto_options"])
                self.mapped_interface_options = self.__class__.mapped_interface_options(service, version, mode, path + ["mapped_interface_options"])
                self.non_conformal_interface_numerics = self.__class__.non_conformal_interface_numerics(service, version, mode, path + ["non_conformal_interface_numerics"])
                self.auto_create = self.__class__.auto_create(service, version, mode, path + ["auto_create"])
                self.coupled_interfaces_inherit_bcs = self.__class__.coupled_interfaces_inherit_bcs(service, version, mode, path + ["coupled_interfaces_inherit_bcs"])
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.create_manually = self.__class__.create_manually(service, version, mode, path + ["create_manually"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                self.delete_interfaces_with_small_overlap = self.__class__.delete_interfaces_with_small_overlap(service, version, mode, path + ["delete_interfaces_with_small_overlap"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.enable_si_with_nodes = self.__class__.enable_si_with_nodes(service, version, mode, path + ["enable_si_with_nodes"])
                self.enable_visualization_of_interfaces = self.__class__.enable_visualization_of_interfaces(service, version, mode, path + ["enable_visualization_of_interfaces"])
                self.enforce_continuity_after_bc = self.__class__.enforce_continuity_after_bc(service, version, mode, path + ["enforce_continuity_after_bc"])
                self.enforce_coupled_wall_between_solids = self.__class__.enforce_coupled_wall_between_solids(service, version, mode, path + ["enforce_coupled_wall_between_solids"])
                self.improve_quality = self.__class__.improve_quality(service, version, mode, path + ["improve_quality"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.make_periodic = self.__class__.make_periodic(service, version, mode, path + ["make_periodic"])
                self.make_phaselag_from_boundaries = self.__class__.make_phaselag_from_boundaries(service, version, mode, path + ["make_phaselag_from_boundaries"])
                self.make_phaselag_from_periodic = self.__class__.make_phaselag_from_periodic(service, version, mode, path + ["make_phaselag_from_periodic"])
                self.non_overlapping_zone_name = self.__class__.non_overlapping_zone_name(service, version, mode, path + ["non_overlapping_zone_name"])
                self.one_to_one_pairing = self.__class__.one_to_one_pairing(service, version, mode, path + ["one_to_one_pairing"])
                self.periodic_repeats_no_flipping = self.__class__.periodic_repeats_no_flipping(service, version, mode, path + ["periodic_repeats_no_flipping"])
                self.remove_left_handed_interface_faces = self.__class__.remove_left_handed_interface_faces(service, version, mode, path + ["remove_left_handed_interface_faces"])
                self.transfer_motion_across_interfaces = self.__class__.transfer_motion_across_interfaces(service, version, mode, path + ["transfer_motion_across_interfaces"])
                self.turbo_create = self.__class__.turbo_create(service, version, mode, path + ["turbo_create"])
                self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                super().__init__(service, version, mode, path)
            class auto_create(TUIMethod):
                """
                .
                """
            class coupled_interfaces_inherit_bcs(TUIMethod):
                """
                .
                """
            class create(TUIMethod):
                """
                Create a mesh interface.
                """
            class create_manually(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class delete_all(TUIMethod):
                """
                Delete all mesh interfaces.
                """
            class delete_interfaces_with_small_overlap(TUIMethod):
                """
                .
                """
            class display(TUIMethod):
                """
                .
                """
            class edit(TUIMethod):
                """
                Edit a mesh interface.
                """
            class enable_si_with_nodes(TUIMethod):
                """
                .
                """
            class enable_visualization_of_interfaces(TUIMethod):
                """
                .
                """
            class enforce_continuity_after_bc(TUIMethod):
                """
                .
                """
            class enforce_coupled_wall_between_solids(TUIMethod):
                """
                .
                """
            class improve_quality(TUIMethod):
                """
                Improve mesh interface quality.
                """
            class list(TUIMethod):
                """
                .
                """
            class make_periodic(TUIMethod):
                """
                Make interface zones periodic.
                """
            class make_phaselag_from_boundaries(TUIMethod):
                """
                .
                """
            class make_phaselag_from_periodic(TUIMethod):
                """
                .
                """
            class non_overlapping_zone_name(TUIMethod):
                """
                .
                """
            class one_to_one_pairing(TUIMethod):
                """
                .
                """
            class periodic_repeats_no_flipping(TUIMethod):
                """
                Enable periodic repeats no flipping.
                """
            class remove_left_handed_interface_faces(TUIMethod):
                """
                .
                """
            class transfer_motion_across_interfaces(TUIMethod):
                """
                .
                """
            class turbo_create(TUIMethod):
                """
                .
                """
            class verbosity(TUIMethod):
                """
                .
                """

            class auto_options(TUIMenu):
                """
                Enter auto-options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.keep_empty_interface = self.__class__.keep_empty_interface(service, version, mode, path + ["keep_empty_interface"])
                    self.naming_option = self.__class__.naming_option(service, version, mode, path + ["naming_option"])
                    self.pairing_between_different_cell_zones_only = self.__class__.pairing_between_different_cell_zones_only(service, version, mode, path + ["pairing_between_different_cell_zones_only"])
                    self.pairing_between_interface_zones_only = self.__class__.pairing_between_interface_zones_only(service, version, mode, path + ["pairing_between_interface_zones_only"])
                    self.proximity_tolerance = self.__class__.proximity_tolerance(service, version, mode, path + ["proximity_tolerance"])
                    self.set_default_name_prefix = self.__class__.set_default_name_prefix(service, version, mode, path + ["set_default_name_prefix"])
                    self.set_exclusion_pairs = self.__class__.set_exclusion_pairs(service, version, mode, path + ["set_exclusion_pairs"])
                    self.set_minimum_area_percentage = self.__class__.set_minimum_area_percentage(service, version, mode, path + ["set_minimum_area_percentage"])
                    self.set_one_to_one_pairing_tolerance = self.__class__.set_one_to_one_pairing_tolerance(service, version, mode, path + ["set_one_to_one_pairing_tolerance"])
                    super().__init__(service, version, mode, path)
                class keep_empty_interface(TUIMethod):
                    """
                    .
                    """
                class naming_option(TUIMethod):
                    """
                    .
                    """
                class pairing_between_different_cell_zones_only(TUIMethod):
                    """
                    .
                    """
                class pairing_between_interface_zones_only(TUIMethod):
                    """
                    .
                    """
                class proximity_tolerance(TUIMethod):
                    """
                    .
                    """
                class set_default_name_prefix(TUIMethod):
                    """
                    .
                    """
                class set_exclusion_pairs(TUIMethod):
                    """
                    .
                    """
                class set_minimum_area_percentage(TUIMethod):
                    """
                    .
                    """
                class set_one_to_one_pairing_tolerance(TUIMethod):
                    """
                    .
                    """

            class mapped_interface_options(TUIMenu):
                """
                Enter the mapped-interface-options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.convert_to_mapped_interface = self.__class__.convert_to_mapped_interface(service, version, mode, path + ["convert_to_mapped_interface"])
                    self.solution_controls = self.__class__.solution_controls(service, version, mode, path + ["solution_controls"])
                    self.tolerance = self.__class__.tolerance(service, version, mode, path + ["tolerance"])
                    super().__init__(service, version, mode, path)
                class convert_to_mapped_interface(TUIMethod):
                    """
                    .
                    """
                class solution_controls(TUIMethod):
                    """
                    .
                    """
                class tolerance(TUIMethod):
                    """
                    .
                    """

            class non_conformal_interface_numerics(TUIMenu):
                """
                Setting non-conformal numerics options.
                """
                def __init__(self, service, version, mode, path):
                    self.change_numerics = self.__class__.change_numerics(service, version, mode, path + ["change_numerics"])
                    super().__init__(service, version, mode, path)
                class change_numerics(TUIMethod):
                    """
                    .
                    """

        class mixing_planes(TUIMenu):
            """
            Enter the mixing planes menu.
            """
            def __init__(self, service, version, mode, path):
                self.set = self.__class__.set(service, version, mode, path + ["set"])
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                super().__init__(service, version, mode, path)
            class create(TUIMethod):
                """
                Create a mixing plane.
                """
            class delete(TUIMethod):
                """
                Delete a mixing plane.
                """
            class list(TUIMethod):
                """
                List defined mixing plane(s).
                """

            class set(TUIMenu):
                """
                Enter the mixing plane set menu.
                """
                def __init__(self, service, version, mode, path):
                    self.conserve_swirl = self.__class__.conserve_swirl(service, version, mode, path + ["conserve_swirl"])
                    self.conserve_total_enthalpy = self.__class__.conserve_total_enthalpy(service, version, mode, path + ["conserve_total_enthalpy"])
                    self.averaging_method = self.__class__.averaging_method(service, version, mode, path + ["averaging_method"])
                    self.fix_pressure_level = self.__class__.fix_pressure_level(service, version, mode, path + ["fix_pressure_level"])
                    self.under_relaxation = self.__class__.under_relaxation(service, version, mode, path + ["under_relaxation"])
                    super().__init__(service, version, mode, path)
                class averaging_method(TUIMethod):
                    """
                    Set mixing plane profile averaging method.
                    """
                class fix_pressure_level(TUIMethod):
                    """
                    Set fix pressure level using define/reference-pressure-location.
                    """
                class under_relaxation(TUIMethod):
                    """
                    Set mixing plane under-relaxation factor.
                    """

                class conserve_swirl(TUIMenu):
                    """
                    Enter the mixing plane conserve-swirl menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                        self.report_swirl_integration = self.__class__.report_swirl_integration(service, version, mode, path + ["report_swirl_integration"])
                        self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                        super().__init__(service, version, mode, path)
                    class enable(TUIMethod):
                        """
                        Enable/disable swirl conservation in mixing plane.
                        """
                    class report_swirl_integration(TUIMethod):
                        """
                        Report swirl integration (torque) on inflow and outflow zones.
                        """
                    class verbosity(TUIMethod):
                        """
                        Enable/disable verbosity in swirl conservation calculations.
                        """

                class conserve_total_enthalpy(TUIMenu):
                    """
                    Enter the menu to set total enthalpy conservation in mixing plane menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                        self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                        super().__init__(service, version, mode, path)
                    class enable(TUIMethod):
                        """
                        Enable/disable total enthalpy conservation in mixing plane.
                        """
                    class verbosity(TUIMethod):
                        """
                        Enable/disable verbosity in total-enthalpy conservation calculations.
                        """

        class models(TUIMenu):
            """
            Enter the models menu to configure the solver.
            """
            def __init__(self, service, version, mode, path):
                self.acoustics = self.__class__.acoustics(service, version, mode, path + ["acoustics"])
                self.cht = self.__class__.cht(service, version, mode, path + ["cht"])
                self.dpm = self.__class__.dpm(service, version, mode, path + ["dpm"])
                self.electrolysis_setup = self.__class__.electrolysis_setup(service, version, mode, path + ["electrolysis_setup"])
                self.eulerian_wallfilm = self.__class__.eulerian_wallfilm(service, version, mode, path + ["eulerian_wallfilm"])
                self.heat_exchanger = self.__class__.heat_exchanger(service, version, mode, path + ["heat_exchanger"])
                self.multiphase = self.__class__.multiphase(service, version, mode, path + ["multiphase"])
                self.nox_parameters = self.__class__.nox_parameters(service, version, mode, path + ["nox_parameters"])
                self.optics = self.__class__.optics(service, version, mode, path + ["optics"])
                self.radiation = self.__class__.radiation(service, version, mode, path + ["radiation"])
                self.shell_conduction = self.__class__.shell_conduction(service, version, mode, path + ["shell_conduction"])
                self.solver = self.__class__.solver(service, version, mode, path + ["solver"])
                self.soot_parameters = self.__class__.soot_parameters(service, version, mode, path + ["soot_parameters"])
                self.species = self.__class__.species(service, version, mode, path + ["species"])
                self.structure = self.__class__.structure(service, version, mode, path + ["structure"])
                self.system_coupling_settings = self.__class__.system_coupling_settings(service, version, mode, path + ["system_coupling_settings"])
                self.two_temperature = self.__class__.two_temperature(service, version, mode, path + ["two_temperature"])
                self.virtual_blade_model = self.__class__.virtual_blade_model(service, version, mode, path + ["virtual_blade_model"])
                self.viscous = self.__class__.viscous(service, version, mode, path + ["viscous"])
                self.ablation = self.__class__.ablation(service, version, mode, path + ["ablation"])
                self.addon_module = self.__class__.addon_module(service, version, mode, path + ["addon_module"])
                self.axisymmetric = self.__class__.axisymmetric(service, version, mode, path + ["axisymmetric"])
                self.battery_model = self.__class__.battery_model(service, version, mode, path + ["battery_model"])
                self.crevice_model = self.__class__.crevice_model(service, version, mode, path + ["crevice_model"])
                self.crevice_model_controls = self.__class__.crevice_model_controls(service, version, mode, path + ["crevice_model_controls"])
                self.energy = self.__class__.energy(service, version, mode, path + ["energy"])
                self.frozen_flux = self.__class__.frozen_flux(service, version, mode, path + ["frozen_flux"])
                self.noniterative_time_advance = self.__class__.noniterative_time_advance(service, version, mode, path + ["noniterative_time_advance"])
                self.nox = self.__class__.nox(service, version, mode, path + ["nox"])
                self.potential_and_li_ion_battery = self.__class__.potential_and_li_ion_battery(service, version, mode, path + ["potential_and_li_ion_battery"])
                self.solidification_melting = self.__class__.solidification_melting(service, version, mode, path + ["solidification_melting"])
                self.soot = self.__class__.soot(service, version, mode, path + ["soot"])
                self.steady = self.__class__.steady(service, version, mode, path + ["steady"])
                self.swirl = self.__class__.swirl(service, version, mode, path + ["swirl"])
                self.unsteady_1st_order = self.__class__.unsteady_1st_order(service, version, mode, path + ["unsteady_1st_order"])
                self.unsteady_2nd_order = self.__class__.unsteady_2nd_order(service, version, mode, path + ["unsteady_2nd_order"])
                self.unsteady_2nd_order_bounded = self.__class__.unsteady_2nd_order_bounded(service, version, mode, path + ["unsteady_2nd_order_bounded"])
                self.unsteady_global_time = self.__class__.unsteady_global_time(service, version, mode, path + ["unsteady_global_time"])
                self.unsteady_structure_euler = self.__class__.unsteady_structure_euler(service, version, mode, path + ["unsteady_structure_euler"])
                self.unsteady_structure_newmark = self.__class__.unsteady_structure_newmark(service, version, mode, path + ["unsteady_structure_newmark"])
                self.use_limiter_in_time = self.__class__.use_limiter_in_time(service, version, mode, path + ["use_limiter_in_time"])
                super().__init__(service, version, mode, path)
            class ablation(TUIMethod):
                """
                .
                """
            class addon_module(TUIMethod):
                """
                Load addon module.
                """
            class axisymmetric(TUIMethod):
                """
                Enable/disable the axisymmetric model.
                """
            class battery_model(TUIMethod):
                """
                Enter battery model menu.
                """
            class crevice_model(TUIMethod):
                """
                Enable/disable the crevice model.
                """
            class crevice_model_controls(TUIMethod):
                """
                Enter the crevice model controls menu.
                """
            class energy(TUIMethod):
                """
                .
                """
            class frozen_flux(TUIMethod):
                """
                .
                """
            class noniterative_time_advance(TUIMethod):
                """
                .
                """
            class nox(TUIMethod):
                """
                Enable/disable the NOx model.
                """
            class potential_and_li_ion_battery(TUIMethod):
                """
                Enable/disable the electric-potential model.
                """
            class solidification_melting(TUIMethod):
                """
                Enable/disable the solidification and melting model.
                """
            class soot(TUIMethod):
                """
                Enable/disable the soot model.
                """
            class steady(TUIMethod):
                """
                Enable/disable the steady solution model.
                """
            class swirl(TUIMethod):
                """
                Enable/disable axisymmetric swirl velocity.
                """
            class unsteady_1st_order(TUIMethod):
                """
                Enable/disable first-order unsteady solution model.
                """
            class unsteady_2nd_order(TUIMethod):
                """
                Enable/disable the second-order unsteady solution model.
                """
            class unsteady_2nd_order_bounded(TUIMethod):
                """
                Enable/disable bounded second-order unsteady formulation.
                """
            class unsteady_global_time(TUIMethod):
                """
                Enable/disable the unsteady global-time-step solution model.
                """
            class unsteady_structure_euler(TUIMethod):
                """
                Enable/disable Backward Euler unsteady solution model.
                """
            class unsteady_structure_newmark(TUIMethod):
                """
                Enable/disable Newmark unsteady solution model.
                """
            class use_limiter_in_time(TUIMethod):
                """
                .
                """

            class acoustics(TUIMenu):
                """
                Enter the acoustics model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.far_field_parameters = self.__class__.far_field_parameters(service, version, mode, path + ["far_field_parameters"])
                    self.sources_fft = self.__class__.sources_fft(service, version, mode, path + ["sources_fft"])
                    self.sponge_layers = self.__class__.sponge_layers(service, version, mode, path + ["sponge_layers"])
                    self.wave_equation_options = self.__class__.wave_equation_options(service, version, mode, path + ["wave_equation_options"])
                    self.acoustic_modal_analysis = self.__class__.acoustic_modal_analysis(service, version, mode, path + ["acoustic_modal_analysis"])
                    self.auto_prune = self.__class__.auto_prune(service, version, mode, path + ["auto_prune"])
                    self.broad_band_noise = self.__class__.broad_band_noise(service, version, mode, path + ["broad_band_noise"])
                    self.compute_write = self.__class__.compute_write(service, version, mode, path + ["compute_write"])
                    self.convective_effects = self.__class__.convective_effects(service, version, mode, path + ["convective_effects"])
                    self.cylindrical_export = self.__class__.cylindrical_export(service, version, mode, path + ["cylindrical_export"])
                    self.display_flow_time = self.__class__.display_flow_time(service, version, mode, path + ["display_flow_time"])
                    self.display_frequencies = self.__class__.display_frequencies(service, version, mode, path + ["display_frequencies"])
                    self.export_source_data = self.__class__.export_source_data(service, version, mode, path + ["export_source_data"])
                    self.export_source_data_cgns = self.__class__.export_source_data_cgns(service, version, mode, path + ["export_source_data_cgns"])
                    self.export_volumetric_sources = self.__class__.export_volumetric_sources(service, version, mode, path + ["export_volumetric_sources"])
                    self.export_volumetric_sources_cgns = self.__class__.export_volumetric_sources_cgns(service, version, mode, path + ["export_volumetric_sources_cgns"])
                    self.ffowcs_williams = self.__class__.ffowcs_williams(service, version, mode, path + ["ffowcs_williams"])
                    self.modal_analysis = self.__class__.modal_analysis(service, version, mode, path + ["modal_analysis"])
                    self.moving_receiver = self.__class__.moving_receiver(service, version, mode, path + ["moving_receiver"])
                    self.off = self.__class__.off(service, version, mode, path + ["off"])
                    self.read_compute_write = self.__class__.read_compute_write(service, version, mode, path + ["read_compute_write"])
                    self.receivers = self.__class__.receivers(service, version, mode, path + ["receivers"])
                    self.sources = self.__class__.sources(service, version, mode, path + ["sources"])
                    self.wave_equation = self.__class__.wave_equation(service, version, mode, path + ["wave_equation"])
                    self.write_acoustic_signals = self.__class__.write_acoustic_signals(service, version, mode, path + ["write_acoustic_signals"])
                    self.write_centroid_info = self.__class__.write_centroid_info(service, version, mode, path + ["write_centroid_info"])
                    super().__init__(service, version, mode, path)
                class acoustic_modal_analysis(TUIMethod):
                    """
                    Iterate linear acoustic solver to compute the resonance frequencies and the acoustic modes.
                    """
                class auto_prune(TUIMethod):
                    """
                    Enable/disable auto prune of the receiver signal(s) during read-and-compute.
                    """
                class broad_band_noise(TUIMethod):
                    """
                    Enable/disable the broadband noise model.
                    """
                class compute_write(TUIMethod):
                    """
                    Compute sound pressure.
                    """
                class convective_effects(TUIMethod):
                    """
                    Enable/disable convective effects option.
                    """
                class cylindrical_export(TUIMethod):
                    """
                    Enable/disable the export data in cylindrical coordinates.
                    """
                class display_flow_time(TUIMethod):
                    """
                    Enable/disable the display of flow time during read-and-compute.
                    """
                class display_frequencies(TUIMethod):
                    """
                    Display resonance frequencies.
                    """
                class export_source_data(TUIMethod):
                    """
                    Enable export acoustic source data in ASD format independently of the FW-H model.
                    """
                class export_source_data_cgns(TUIMethod):
                    """
                    Export acoustic source data in CGNS format.
                    """
                class export_volumetric_sources(TUIMethod):
                    """
                    Enable/disable the export of fluid zones.
                    """
                class export_volumetric_sources_cgns(TUIMethod):
                    """
                    Enable/disable the export of fluid zones.
                    """
                class ffowcs_williams(TUIMethod):
                    """
                    Enable/disable the Ffowcs-Williams-and-Hawkings model.
                    """
                class modal_analysis(TUIMethod):
                    """
                    Enable/disable the modal analysis model.
                    """
                class moving_receiver(TUIMethod):
                    """
                    Enable/disable moving receiver option.
                    """
                class off(TUIMethod):
                    """
                    Enable/disable the acoustics model.
                    """
                class read_compute_write(TUIMethod):
                    """
                    Read acoustic source data files and compute sound pressure.
                    """
                class receivers(TUIMethod):
                    """
                    Set acoustic receivers.
                    """
                class sources(TUIMethod):
                    """
                    Set acoustic sources.
                    """
                class wave_equation(TUIMethod):
                    """
                    Enable/disable the wave equation model.
                    """
                class write_acoustic_signals(TUIMethod):
                    """
                    Write on-the-fly sound pressure.
                    """
                class write_centroid_info(TUIMethod):
                    """
                    Write centroid info.
                    """

                class far_field_parameters(TUIMenu):
                    """
                    Enter the far field parameters menu for the wave equation model.
                    """
                    def __init__(self, service, version, mode, path):
                        self.far_field_density = self.__class__.far_field_density(service, version, mode, path + ["far_field_density"])
                        self.far_field_sound_speed = self.__class__.far_field_sound_speed(service, version, mode, path + ["far_field_sound_speed"])
                        super().__init__(service, version, mode, path)
                    class far_field_density(TUIMethod):
                        """
                        Specify far field density.
                        """
                    class far_field_sound_speed(TUIMethod):
                        """
                        Specify far field speed of sound.
                        """

                class sources_fft(TUIMenu):
                    """
                    Enter the acoustic sources FFT menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.fft_surface_variables = self.__class__.fft_surface_variables(service, version, mode, path + ["fft_surface_variables"])
                        self.clean_up_storage_area = self.__class__.clean_up_storage_area(service, version, mode, path + ["clean_up_storage_area"])
                        self.compute_fft_fields = self.__class__.compute_fft_fields(service, version, mode, path + ["compute_fft_fields"])
                        self.read_asd_files = self.__class__.read_asd_files(service, version, mode, path + ["read_asd_files"])
                        self.write_cgns_files = self.__class__.write_cgns_files(service, version, mode, path + ["write_cgns_files"])
                        super().__init__(service, version, mode, path)
                    class clean_up_storage_area(TUIMethod):
                        """
                        Clean up storage area.
                        """
                    class compute_fft_fields(TUIMethod):
                        """
                        Compute FFT fields.
                        """
                    class read_asd_files(TUIMethod):
                        """
                        Read ASD files.
                        """
                    class write_cgns_files(TUIMethod):
                        """
                        Write CGNS files.
                        """

                    class fft_surface_variables(TUIMenu):
                        """
                        Enter the FFT surface variables menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.create_constant_width_bands = self.__class__.create_constant_width_bands(service, version, mode, path + ["create_constant_width_bands"])
                            self.create_octave_bands = self.__class__.create_octave_bands(service, version, mode, path + ["create_octave_bands"])
                            self.create_set_of_modes = self.__class__.create_set_of_modes(service, version, mode, path + ["create_set_of_modes"])
                            self.create_third_bands = self.__class__.create_third_bands(service, version, mode, path + ["create_third_bands"])
                            self.remove_variables = self.__class__.remove_variables(service, version, mode, path + ["remove_variables"])
                            super().__init__(service, version, mode, path)
                        class create_constant_width_bands(TUIMethod):
                            """
                            Create constant-width bands.
                            """
                        class create_octave_bands(TUIMethod):
                            """
                            Create octave bands.
                            """
                        class create_set_of_modes(TUIMethod):
                            """
                            Create set of modes.
                            """
                        class create_third_bands(TUIMethod):
                            """
                            Create third bands.
                            """
                        class remove_variables(TUIMethod):
                            """
                            Remove variables.
                            """

                class sponge_layers(TUIMenu):
                    """
                    Manage sponge layers where density is blended to eliminate reflections from boundary zones.
                    """
                    def __init__(self, service, version, mode, path):
                        self.activate = self.__class__.activate(service, version, mode, path + ["activate"])
                        self.add = self.__class__.add(service, version, mode, path + ["add"])
                        self.deactivate = self.__class__.deactivate(service, version, mode, path + ["deactivate"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_active = self.__class__.list_active(service, version, mode, path + ["list_active"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        super().__init__(service, version, mode, path)
                    class activate(TUIMethod):
                        """
                        Activate a sponge object.
                        """
                    class add(TUIMethod):
                        """
                        Add a new sponge layer definition.
                        """
                    class deactivate(TUIMethod):
                        """
                        Deactivate a sponge layer definition.
                        """
                    class delete(TUIMethod):
                        """
                        Delete a sponge layer definition.
                        """
                    class edit(TUIMethod):
                        """
                        Edit a sponge layer definition.
                        """
                    class list(TUIMethod):
                        """
                        List the names of the sponge layer definitions.
                        """
                    class list_active(TUIMethod):
                        """
                        List the names of the active sponge layer definitions.
                        """
                    class list_properties(TUIMethod):
                        """
                        List the properties of a sponge layer definition.
                        """

                class wave_equation_options(TUIMenu):
                    """
                    Enter the options menu for the wave equation model.
                    """
                    def __init__(self, service, version, mode, path):
                        self.basic_shapes = self.__class__.basic_shapes(service, version, mode, path + ["basic_shapes"])
                        self.remote_receivers_options = self.__class__.remote_receivers_options(service, version, mode, path + ["remote_receivers_options"])
                        self.remote_receivers = self.__class__.remote_receivers(service, version, mode, path + ["remote_receivers"])
                        self.source_mask_udf = self.__class__.source_mask_udf(service, version, mode, path + ["source_mask_udf"])
                        self.sponge_layer_base_level = self.__class__.sponge_layer_base_level(service, version, mode, path + ["sponge_layer_base_level"])
                        self.sponge_layer_factor = self.__class__.sponge_layer_factor(service, version, mode, path + ["sponge_layer_factor"])
                        self.sponge_layer_udf = self.__class__.sponge_layer_udf(service, version, mode, path + ["sponge_layer_udf"])
                        self.time_filter_source = self.__class__.time_filter_source(service, version, mode, path + ["time_filter_source"])
                        super().__init__(service, version, mode, path)
                    class remote_receivers(TUIMethod):
                        """
                        Activate the Kirchhoff's integral method for remote receivers.
                        """
                    class source_mask_udf(TUIMethod):
                        """
                        Select user-defined function for sound source masking.
                        """
                    class sponge_layer_base_level(TUIMethod):
                        """
                        Specify artificial viscosity base level applied everywhere.
                        """
                    class sponge_layer_factor(TUIMethod):
                        """
                        Specify artificial viscosity factor for sponge layer.
                        """
                    class sponge_layer_udf(TUIMethod):
                        """
                        Select user-defined function for sponge layer.
                        """
                    class time_filter_source(TUIMethod):
                        """
                        Activate time-filtering of sound sources.
                        """

                    class basic_shapes(TUIMenu):
                        """
                        Enter the basic shapes menu to build source mask and sponge layer
                        geometry shapes using cell registers.
                        """
                        def __init__(self, service, version, mode, path):
                            self.add_source_mask_shape = self.__class__.add_source_mask_shape(service, version, mode, path + ["add_source_mask_shape"])
                            self.add_sponge_layer_shape = self.__class__.add_sponge_layer_shape(service, version, mode, path + ["add_sponge_layer_shape"])
                            self.list_region_registers = self.__class__.list_region_registers(service, version, mode, path + ["list_region_registers"])
                            self.list_source_mask_shapes = self.__class__.list_source_mask_shapes(service, version, mode, path + ["list_source_mask_shapes"])
                            self.list_sponge_layer_shapes = self.__class__.list_sponge_layer_shapes(service, version, mode, path + ["list_sponge_layer_shapes"])
                            self.remove_source_mask_shape = self.__class__.remove_source_mask_shape(service, version, mode, path + ["remove_source_mask_shape"])
                            self.remove_sponge_layer_shape = self.__class__.remove_sponge_layer_shape(service, version, mode, path + ["remove_sponge_layer_shape"])
                            super().__init__(service, version, mode, path)
                        class add_source_mask_shape(TUIMethod):
                            """
                            Add a region register for the source mask.
                            """
                        class add_sponge_layer_shape(TUIMethod):
                            """
                            Add a region register for the sponge layer.
                            """
                        class list_region_registers(TUIMethod):
                            """
                            List all available region registers (hex/cylinder/sphere).
                            """
                        class list_source_mask_shapes(TUIMethod):
                            """
                            List all active source mask registers.
                            """
                        class list_sponge_layer_shapes(TUIMethod):
                            """
                            List all active sponge layer registers.
                            """
                        class remove_source_mask_shape(TUIMethod):
                            """
                            Remove a region register from the source mask.
                            """
                        class remove_sponge_layer_shape(TUIMethod):
                            """
                            Remove a region register from the sponge layer.
                            """

                    class remote_receivers_options(TUIMenu):
                        """
                        Enter the menu to set up the Kirchhoff's integral method and output its results.
                        """
                        def __init__(self, service, version, mode, path):
                            self.integration_surface = self.__class__.integration_surface(service, version, mode, path + ["integration_surface"])
                            self.write_signals = self.__class__.write_signals(service, version, mode, path + ["write_signals"])
                            super().__init__(service, version, mode, path)
                        class integration_surface(TUIMethod):
                            """
                            Select Kirchhoff's integration surface.
                            """
                        class write_signals(TUIMethod):
                            """
                            Write signals calculated at receiver locations.
                            """

            class cht(TUIMenu):
                """
                Enter the mapped interface model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.explicit_time_averaged_coupling = self.__class__.explicit_time_averaged_coupling(service, version, mode, path + ["explicit_time_averaged_coupling"])
                    self.implicit_coupling = self.__class__.implicit_coupling(service, version, mode, path + ["implicit_coupling"])
                    self.read_mi_type_wall = self.__class__.read_mi_type_wall(service, version, mode, path + ["read_mi_type_wall"])
                    self.write_mi_type_wall = self.__class__.write_mi_type_wall(service, version, mode, path + ["write_mi_type_wall"])
                    super().__init__(service, version, mode, path)
                class implicit_coupling(TUIMethod):
                    """
                    Enable/disable implicit coupling for mapped interface.
                    """
                class read_mi_type_wall(TUIMethod):
                    """
                    Read mapped interface data settings from a csv file.
                    """
                class write_mi_type_wall(TUIMethod):
                    """
                    Write mapped interface settings to a scv file.
                    """

                class explicit_time_averaged_coupling(TUIMenu):
                    """
                    Enter the explcit time averaged thermal coupling menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.conformal_coupled_walls = self.__class__.conformal_coupled_walls(service, version, mode, path + ["conformal_coupled_walls"])
                        self.coupling_controls = self.__class__.coupling_controls(service, version, mode, path + ["coupling_controls"])
                        self.fuse_explicit_cht_zones = self.__class__.fuse_explicit_cht_zones(service, version, mode, path + ["fuse_explicit_cht_zones"])
                        self.mapped_interfaces = self.__class__.mapped_interfaces(service, version, mode, path + ["mapped_interfaces"])
                        super().__init__(service, version, mode, path)
                    class conformal_coupled_walls(TUIMethod):
                        """
                        Select fluid-solid coupled walls (without shell) for explicit coupling using time averaged thermal variables.
                        """
                    class coupling_controls(TUIMethod):
                        """
                        Specify explcit coupling controls.
                        """
                    class fuse_explicit_cht_zones(TUIMethod):
                        """
                        Fuse slitted conformal coupled walls marked for transient explicit thermal coupling.
                        """
                    class mapped_interfaces(TUIMethod):
                        """
                        Select fluid-solid mapped interfaces for explicit coupling using time averaged thermal variables.
                        """

            class dpm(TUIMenu):
                """
                Enter the dispersed phase model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.collisions = self.__class__.collisions(service, version, mode, path + ["collisions"])
                    self.erosion_dynamic_mesh = self.__class__.erosion_dynamic_mesh(service, version, mode, path + ["erosion_dynamic_mesh"])
                    self.interaction = self.__class__.interaction(service, version, mode, path + ["interaction"])
                    self.numerics = self.__class__.numerics(service, version, mode, path + ["numerics"])
                    self.options = self.__class__.options(service, version, mode, path + ["options"])
                    self.parallel = self.__class__.parallel(service, version, mode, path + ["parallel"])
                    self.splash_options = self.__class__.splash_options(service, version, mode, path + ["splash_options"])
                    self.stripping_options = self.__class__.stripping_options(service, version, mode, path + ["stripping_options"])
                    self.clear_particles_from_domain = self.__class__.clear_particles_from_domain(service, version, mode, path + ["clear_particles_from_domain"])
                    self.fill_injection_material_sources = self.__class__.fill_injection_material_sources(service, version, mode, path + ["fill_injection_material_sources"])
                    self.injections = self.__class__.injections(service, version, mode, path + ["injections"])
                    self.spray_model = self.__class__.spray_model(service, version, mode, path + ["spray_model"])
                    self.unsteady_tracking = self.__class__.unsteady_tracking(service, version, mode, path + ["unsteady_tracking"])
                    self.user_defined = self.__class__.user_defined(service, version, mode, path + ["user_defined"])
                    super().__init__(service, version, mode, path)
                class clear_particles_from_domain(TUIMethod):
                    """
                    Remove/keep all particles currently in the domain.
                    """
                class fill_injection_material_sources(TUIMethod):
                    """
                    Initialize the DPM sources corresponding to each material.
                    """
                class injections(TUIMethod):
                    """
                    Enter the injections menu.
                    """
                class spray_model(TUIMethod):
                    """
                    Enter the spray model menu.
                    """
                class unsteady_tracking(TUIMethod):
                    """
                    Enable/disable unsteady particle tracking.
                    """
                class user_defined(TUIMethod):
                    """
                    Set DPM user-defined functions.
                    """

                class collisions(TUIMenu):
                    """
                    Enter the DEM collisions menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.collision_partners = self.__class__.collision_partners(service, version, mode, path + ["collision_partners"])
                        self.collision_mesh = self.__class__.collision_mesh(service, version, mode, path + ["collision_mesh"])
                        self.collision_pair_settings = self.__class__.collision_pair_settings(service, version, mode, path + ["collision_pair_settings"])
                        self.dem_collisions = self.__class__.dem_collisions(service, version, mode, path + ["dem_collisions"])
                        self.list_all_pair_settings = self.__class__.list_all_pair_settings(service, version, mode, path + ["list_all_pair_settings"])
                        self.max_particle_velocity = self.__class__.max_particle_velocity(service, version, mode, path + ["max_particle_velocity"])
                        super().__init__(service, version, mode, path)
                    class collision_mesh(TUIMethod):
                        """
                        Input for the collision mesh.
                        """
                    class collision_pair_settings(TUIMethod):
                        """
                        Supply settings for collisions to a pair of collision partners.
                        """
                    class dem_collisions(TUIMethod):
                        """
                        Enable/disable the DEM collision model.
                        """
                    class list_all_pair_settings(TUIMethod):
                        """
                        For each pair of collision partners, lists the collision laws and their parameters.
                        """
                    class max_particle_velocity(TUIMethod):
                        """
                        Set the maximum particle velocity that may arise from collisions.
                        """

                    class collision_partners(TUIMenu):
                        """
                        Manage collision partners.
                        """
                        def __init__(self, service, version, mode, path):
                            self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                            self.create = self.__class__.create(service, version, mode, path + ["create"])
                            self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                            super().__init__(service, version, mode, path)
                        class copy(TUIMethod):
                            """
                            Copy a collision partner.
                            """
                        class create(TUIMethod):
                            """
                            Create a collision partner.
                            """
                        class delete(TUIMethod):
                            """
                            Delete a collision partner.
                            """
                        class list(TUIMethod):
                            """
                            Lists all known collision partners.
                            """
                        class rename(TUIMethod):
                            """
                            Rename a collision partner.
                            """

                class erosion_dynamic_mesh(TUIMenu):
                    """
                    Enter the erosion-dynamic mesh interactions menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.general_parameters = self.__class__.general_parameters(service, version, mode, path + ["general_parameters"])
                        self.run_parameters = self.__class__.run_parameters(service, version, mode, path + ["run_parameters"])
                        self.enable_erosion_dynamic_mesh_coupling = self.__class__.enable_erosion_dynamic_mesh_coupling(service, version, mode, path + ["enable_erosion_dynamic_mesh_coupling"])
                        self.run_simulation = self.__class__.run_simulation(service, version, mode, path + ["run_simulation"])
                        super().__init__(service, version, mode, path)
                    class enable_erosion_dynamic_mesh_coupling(TUIMethod):
                        """
                        Enable mesh deformation due to wall erosion.
                        """
                    class run_simulation(TUIMethod):
                        """
                        Perform coupled erosion-dynamic mesh simulation.
                        """

                    class general_parameters(TUIMenu):
                        """
                        Enter the erosion-dynamic mesh setup menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.dynamic_mesh_settings = self.__class__.dynamic_mesh_settings(service, version, mode, path + ["dynamic_mesh_settings"])
                            self.erosion_settings = self.__class__.erosion_settings(service, version, mode, path + ["erosion_settings"])
                            self.participating_walls = self.__class__.participating_walls(service, version, mode, path + ["participating_walls"])
                            super().__init__(service, version, mode, path)
                        class dynamic_mesh_settings(TUIMethod):
                            """
                            Perform dynamic mesh related setup.
                            """
                        class erosion_settings(TUIMethod):
                            """
                            Set erosion modelling specific settings.
                            """
                        class participating_walls(TUIMethod):
                            """
                            Specify all participating walls.
                            """

                    class run_parameters(TUIMenu):
                        """
                        Enter the erosion-dynamic mesh run menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.autosave_files = self.__class__.autosave_files(service, version, mode, path + ["autosave_files"])
                            self.autosave_graphics = self.__class__.autosave_graphics(service, version, mode, path + ["autosave_graphics"])
                            self.flow_simulation_control = self.__class__.flow_simulation_control(service, version, mode, path + ["flow_simulation_control"])
                            self.mesh_motion_time_step = self.__class__.mesh_motion_time_step(service, version, mode, path + ["mesh_motion_time_step"])
                            self.simulation_termination = self.__class__.simulation_termination(service, version, mode, path + ["simulation_termination"])
                            super().__init__(service, version, mode, path)
                        class autosave_files(TUIMethod):
                            """
                            Set the iteration increment to save data files.
                            """
                        class autosave_graphics(TUIMethod):
                            """
                            Set the iteration increment to save graphics files.
                            """
                        class flow_simulation_control(TUIMethod):
                            """
                            Set number of iterations per flow simulation step.
                            """
                        class mesh_motion_time_step(TUIMethod):
                            """
                            Set the mesh motion time stepping parameters and method.
                            """
                        class simulation_termination(TUIMethod):
                            """
                            Set total time of erosion.
                            """

                class interaction(TUIMenu):
                    """
                    Enter the interaction menu to set parameters for coupled discrete phase calculations.
                    """
                    def __init__(self, service, version, mode, path):
                        self.choice_of_eulerian_phase_for_interaction = self.__class__.choice_of_eulerian_phase_for_interaction(service, version, mode, path + ["choice_of_eulerian_phase_for_interaction"])
                        self.coupled_calculations = self.__class__.coupled_calculations(service, version, mode, path + ["coupled_calculations"])
                        self.ddpm_energy_coupling_via_source_term = self.__class__.ddpm_energy_coupling_via_source_term(service, version, mode, path + ["ddpm_energy_coupling_via_source_term"])
                        self.ddpm_enhanced_inter_phase_exchange = self.__class__.ddpm_enhanced_inter_phase_exchange(service, version, mode, path + ["ddpm_enhanced_inter_phase_exchange"])
                        self.ddpm_iad_particle = self.__class__.ddpm_iad_particle(service, version, mode, path + ["ddpm_iad_particle"])
                        self.dpm_iteration_interval = self.__class__.dpm_iteration_interval(service, version, mode, path + ["dpm_iteration_interval"])
                        self.enable_drag_scaling_due_to_flow_blocking = self.__class__.enable_drag_scaling_due_to_flow_blocking(service, version, mode, path + ["enable_drag_scaling_due_to_flow_blocking"])
                        self.enable_flow_blocking_by_particles = self.__class__.enable_flow_blocking_by_particles(service, version, mode, path + ["enable_flow_blocking_by_particles"])
                        self.enable_mom_source_scaling_due_to_flow_blocking = self.__class__.enable_mom_source_scaling_due_to_flow_blocking(service, version, mode, path + ["enable_mom_source_scaling_due_to_flow_blocking"])
                        self.enable_other_source_scaling_due_to_flow_blocking = self.__class__.enable_other_source_scaling_due_to_flow_blocking(service, version, mode, path + ["enable_other_source_scaling_due_to_flow_blocking"])
                        self.enable_source_scaling_due_to_flow_blocking = self.__class__.enable_source_scaling_due_to_flow_blocking(service, version, mode, path + ["enable_source_scaling_due_to_flow_blocking"])
                        self.enhanced_source_term_linearization_enabled = self.__class__.enhanced_source_term_linearization_enabled(service, version, mode, path + ["enhanced_source_term_linearization_enabled"])
                        self.implicit_momentum_coupling = self.__class__.implicit_momentum_coupling(service, version, mode, path + ["implicit_momentum_coupling"])
                        self.implicit_source_term_coupling = self.__class__.implicit_source_term_coupling(service, version, mode, path + ["implicit_source_term_coupling"])
                        self.keep_linearized_dpm_source_terms_constant = self.__class__.keep_linearized_dpm_source_terms_constant(service, version, mode, path + ["keep_linearized_dpm_source_terms_constant"])
                        self.linear_growth_of_dpm_source_term = self.__class__.linear_growth_of_dpm_source_term(service, version, mode, path + ["linear_growth_of_dpm_source_term"])
                        self.linearized_dpm_mixture_fraction_source_terms = self.__class__.linearized_dpm_mixture_fraction_source_terms(service, version, mode, path + ["linearized_dpm_mixture_fraction_source_terms"])
                        self.linearized_dpm_source_terms = self.__class__.linearized_dpm_source_terms(service, version, mode, path + ["linearized_dpm_source_terms"])
                        self.linearized_dpm_source_terms_limiter = self.__class__.linearized_dpm_source_terms_limiter(service, version, mode, path + ["linearized_dpm_source_terms_limiter"])
                        self.linearized_dpm_species_source_terms = self.__class__.linearized_dpm_species_source_terms(service, version, mode, path + ["linearized_dpm_species_source_terms"])
                        self.max_vf_allowed_for_blocking = self.__class__.max_vf_allowed_for_blocking(service, version, mode, path + ["max_vf_allowed_for_blocking"])
                        self.min_vf_threshold_for_dpm_src_scaling = self.__class__.min_vf_threshold_for_dpm_src_scaling(service, version, mode, path + ["min_vf_threshold_for_dpm_src_scaling"])
                        self.replace_dpm_mass_source_by_mixture_fraction = self.__class__.replace_dpm_mass_source_by_mixture_fraction(service, version, mode, path + ["replace_dpm_mass_source_by_mixture_fraction"])
                        self.reset_sources_at_timestep = self.__class__.reset_sources_at_timestep(service, version, mode, path + ["reset_sources_at_timestep"])
                        self.second_order_time_accurate_sources_enabled = self.__class__.second_order_time_accurate_sources_enabled(service, version, mode, path + ["second_order_time_accurate_sources_enabled"])
                        self.underrelaxation_factor = self.__class__.underrelaxation_factor(service, version, mode, path + ["underrelaxation_factor"])
                        self.update_dpm_sources_every_flow_iteration = self.__class__.update_dpm_sources_every_flow_iteration(service, version, mode, path + ["update_dpm_sources_every_flow_iteration"])
                        super().__init__(service, version, mode, path)
                    class choice_of_eulerian_phase_for_interaction(TUIMethod):
                        """
                        Enable/disable the option to choose for every injection the Eulerian phase for the DPM continuous phase interaction.
                        """
                    class coupled_calculations(TUIMethod):
                        """
                        .
                        """
                    class ddpm_energy_coupling_via_source_term(TUIMethod):
                        """
                        Energy coupling in DDPM established via source term.
                        """
                    class ddpm_enhanced_inter_phase_exchange(TUIMethod):
                        """
                        Enhanced Eulerian inter-phase exchange.
                        """
                    class ddpm_iad_particle(TUIMethod):
                        """
                        Enable/disable the non-default interfacial area method IA-particle.
                        """
                    class dpm_iteration_interval(TUIMethod):
                        """
                        Set the number of continuous phase iterations per DPM iteration.
                        """
                    class enable_drag_scaling_due_to_flow_blocking(TUIMethod):
                        """
                        .
                        """
                    class enable_flow_blocking_by_particles(TUIMethod):
                        """
                        .
                        """
                    class enable_mom_source_scaling_due_to_flow_blocking(TUIMethod):
                        """
                        .
                        """
                    class enable_other_source_scaling_due_to_flow_blocking(TUIMethod):
                        """
                        .
                        """
                    class enable_source_scaling_due_to_flow_blocking(TUIMethod):
                        """
                        Enable/disable scaling of DPM source terms due to inclusion of DPM volume fraction in continuous flow.
                        """
                    class enhanced_source_term_linearization_enabled(TUIMethod):
                        """
                        .
                        """
                    class implicit_momentum_coupling(TUIMethod):
                        """
                        .
                        """
                    class implicit_source_term_coupling(TUIMethod):
                        """
                        .
                        """
                    class keep_linearized_dpm_source_terms_constant(TUIMethod):
                        """
                        .
                        """
                    class linear_growth_of_dpm_source_term(TUIMethod):
                        """
                        .
                        """
                    class linearized_dpm_mixture_fraction_source_terms(TUIMethod):
                        """
                        Perform a linearization of mixture fraction source terms.
                        """
                    class linearized_dpm_source_terms(TUIMethod):
                        """
                        .
                        """
                    class linearized_dpm_source_terms_limiter(TUIMethod):
                        """
                        .
                        """
                    class linearized_dpm_species_source_terms(TUIMethod):
                        """
                        Perform linearization of species source terms.
                        """
                    class max_vf_allowed_for_blocking(TUIMethod):
                        """
                        .
                        """
                    class min_vf_threshold_for_dpm_src_scaling(TUIMethod):
                        """
                        Minimum DPM volume fraction below which no DPM source scaling is applied.
                        """
                    class replace_dpm_mass_source_by_mixture_fraction(TUIMethod):
                        """
                        Recalculate the mixture fraction source terms as function of the primary mixture fraction?.
                        """
                    class reset_sources_at_timestep(TUIMethod):
                        """
                        .
                        """
                    class second_order_time_accurate_sources_enabled(TUIMethod):
                        """
                        .
                        """
                    class underrelaxation_factor(TUIMethod):
                        """
                        .
                        """
                    class update_dpm_sources_every_flow_iteration(TUIMethod):
                        """
                        .
                        """

                class numerics(TUIMenu):
                    """
                    Enter the numerics menu to set numerical solution parameters.
                    """
                    def __init__(self, service, version, mode, path):
                        self.high_resolution_tracking = self.__class__.high_resolution_tracking(service, version, mode, path + ["high_resolution_tracking"])
                        self.automated_scheme_selection = self.__class__.automated_scheme_selection(service, version, mode, path + ["automated_scheme_selection"])
                        self.average_DDPM_variables = self.__class__.average_DDPM_variables(service, version, mode, path + ["average_DDPM_variables"])
                        self.average_each_step = self.__class__.average_each_step(service, version, mode, path + ["average_each_step"])
                        self.average_kernel = self.__class__.average_kernel(service, version, mode, path + ["average_kernel"])
                        self.average_source_terms = self.__class__.average_source_terms(service, version, mode, path + ["average_source_terms"])
                        self.coupled_heat_mass_update = self.__class__.coupled_heat_mass_update(service, version, mode, path + ["coupled_heat_mass_update"])
                        self.drag_law = self.__class__.drag_law(service, version, mode, path + ["drag_law"])
                        self.dynamic_interaction = self.__class__.dynamic_interaction(service, version, mode, path + ["dynamic_interaction"])
                        self.enable_node_based_averaging = self.__class__.enable_node_based_averaging(service, version, mode, path + ["enable_node_based_averaging"])
                        self.enhanced_packing_limit_numerics = self.__class__.enhanced_packing_limit_numerics(service, version, mode, path + ["enhanced_packing_limit_numerics"])
                        self.error_control = self.__class__.error_control(service, version, mode, path + ["error_control"])
                        self.gaussian_factor = self.__class__.gaussian_factor(service, version, mode, path + ["gaussian_factor"])
                        self.granular_stress_tensor = self.__class__.granular_stress_tensor(service, version, mode, path + ["granular_stress_tensor"])
                        self.limit_granular_forces = self.__class__.limit_granular_forces(service, version, mode, path + ["limit_granular_forces"])
                        self.minimum_liquid_fraction = self.__class__.minimum_liquid_fraction(service, version, mode, path + ["minimum_liquid_fraction"])
                        self.mppic_settings = self.__class__.mppic_settings(service, version, mode, path + ["mppic_settings"])
                        self.packed_region_detection_enabled = self.__class__.packed_region_detection_enabled(service, version, mode, path + ["packed_region_detection_enabled"])
                        self.parcel_count_control = self.__class__.parcel_count_control(service, version, mode, path + ["parcel_count_control"])
                        self.predictor_corrector = self.__class__.predictor_corrector(service, version, mode, path + ["predictor_corrector"])
                        self.re_randomize_every_iteration = self.__class__.re_randomize_every_iteration(service, version, mode, path + ["re_randomize_every_iteration"])
                        self.re_randomize_every_timestep = self.__class__.re_randomize_every_timestep(service, version, mode, path + ["re_randomize_every_timestep"])
                        self.source_terms_cell_cloud_limit = self.__class__.source_terms_cell_cloud_limit(service, version, mode, path + ["source_terms_cell_cloud_limit"])
                        self.tracking_parameters = self.__class__.tracking_parameters(service, version, mode, path + ["tracking_parameters"])
                        self.tracking_scheme = self.__class__.tracking_scheme(service, version, mode, path + ["tracking_scheme"])
                        self.tracking_statistics = self.__class__.tracking_statistics(service, version, mode, path + ["tracking_statistics"])
                        self.underrelax_film_height = self.__class__.underrelax_film_height(service, version, mode, path + ["underrelax_film_height"])
                        self.use_advanced_settings_for_epln = self.__class__.use_advanced_settings_for_epln(service, version, mode, path + ["use_advanced_settings_for_epln"])
                        self.use_cell_based_vof_for_epln = self.__class__.use_cell_based_vof_for_epln(service, version, mode, path + ["use_cell_based_vof_for_epln"])
                        self.vaporization_limiting_factors = self.__class__.vaporization_limiting_factors(service, version, mode, path + ["vaporization_limiting_factors"])
                        self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                        super().__init__(service, version, mode, path)
                    class automated_scheme_selection(TUIMethod):
                        """
                        Enable/disable the adaptation of integration step length based on a maximum error.
                        """
                    class average_DDPM_variables(TUIMethod):
                        """
                        Average DDPM specific variables like volume fractions and velocities on nodes.
                        """
                    class average_each_step(TUIMethod):
                        """
                        .
                        """
                    class average_kernel(TUIMethod):
                        """
                        .
                        """
                    class average_source_terms(TUIMethod):
                        """
                        .
                        """
                    class coupled_heat_mass_update(TUIMethod):
                        """
                        Enable/disable coupled heat and mass update.
                        """
                    class drag_law(TUIMethod):
                        """
                        Set the drag law.
                        """
                    class dynamic_interaction(TUIMethod):
                        """
                        Enable/disable dynamic interaction range.
                        """
                    class enable_node_based_averaging(TUIMethod):
                        """
                        .
                        """
                    class enhanced_packing_limit_numerics(TUIMethod):
                        """
                        Enable enhanced packing limit numerics to avoid exceeding of packing limit for granular phases.
                        """
                    class error_control(TUIMethod):
                        """
                        Set the adapt integration step length based on a maximum error.
                        """
                    class gaussian_factor(TUIMethod):
                        """
                        .
                        """
                    class granular_stress_tensor(TUIMethod):
                        """
                        Enable granular stress tensor to be considered with solid pressure gradient as collision force.
                        """
                    class limit_granular_forces(TUIMethod):
                        """
                        Enable limiting of granular forces from solid pressure gradients to avoid particle velocity overshoots.
                        """
                    class minimum_liquid_fraction(TUIMethod):
                        """
                        Evaporate droplet completely when the remaining mass is below this fraction of initial mass.
                        """
                    class mppic_settings(TUIMethod):
                        """
                        Enable PIC and MPPIC to compute DPM and DDPM source terms.
                        """
                    class packed_region_detection_enabled(TUIMethod):
                        """
                        Identify cells in packed region to apply limiting of granular forces.
                        """
                    class parcel_count_control(TUIMethod):
                        """
                        .
                        """
                    class predictor_corrector(TUIMethod):
                        """
                        Enable predictor/corrector approach to track particles.
                        """
                    class re_randomize_every_iteration(TUIMethod):
                        """
                        Decide whether pseudo-random number sequences shall vary from iteration to iteration or not.
                        """
                    class re_randomize_every_timestep(TUIMethod):
                        """
                        Decide whether pseudo-random number sequences shall vary from timestep to timestep or not.
                        """
                    class source_terms_cell_cloud_limit(TUIMethod):
                        """
                        Limiting particle source terms based on minimum of particle cloud volume and cell volume.
                        """
                    class tracking_parameters(TUIMethod):
                        """
                        Set parameters for the (initial) tracking step length.
                        """
                    class tracking_scheme(TUIMethod):
                        """
                        Specify a tracking scheme.
                        """
                    class tracking_statistics(TUIMethod):
                        """
                        .
                        """
                    class underrelax_film_height(TUIMethod):
                        """
                        Define underrelaxation factor for film height.
                        """
                    class use_advanced_settings_for_epln(TUIMethod):
                        """
                        Enable/Disable advanced settings for enhanced packing limit numerics.
                        """
                    class use_cell_based_vof_for_epln(TUIMethod):
                        """
                        Use cell based VOF for enhanced packing limit numerics.
                        """
                    class vaporization_limiting_factors(TUIMethod):
                        """
                        Set Vaporization Fractional Change Limits.
                        """
                    class verbosity(TUIMethod):
                        """
                        .
                        """

                    class high_resolution_tracking(TUIMenu):
                        """
                        Enter the high resolution tracking menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.barycentric_interpolation = self.__class__.barycentric_interpolation(service, version, mode, path + ["barycentric_interpolation"])
                            self.particle_relocation = self.__class__.particle_relocation(service, version, mode, path + ["particle_relocation"])
                            self.always_use_face_centroid_with_periodics = self.__class__.always_use_face_centroid_with_periodics(service, version, mode, path + ["always_use_face_centroid_with_periodics"])
                            self.boundary_layer_tracking = self.__class__.boundary_layer_tracking(service, version, mode, path + ["boundary_layer_tracking"])
                            self.check_subtet_validity = self.__class__.check_subtet_validity(service, version, mode, path + ["check_subtet_validity"])
                            self.enable_automatic_intersection_tolerance = self.__class__.enable_automatic_intersection_tolerance(service, version, mode, path + ["enable_automatic_intersection_tolerance"])
                            self.enable_barycentric_intersections = self.__class__.enable_barycentric_intersections(service, version, mode, path + ["enable_barycentric_intersections"])
                            self.enable_high_resolution_tracking = self.__class__.enable_high_resolution_tracking(service, version, mode, path + ["enable_high_resolution_tracking"])
                            self.enhanced_wallfilm_location_method = self.__class__.enhanced_wallfilm_location_method(service, version, mode, path + ["enhanced_wallfilm_location_method"])
                            self.load_legacy_particles = self.__class__.load_legacy_particles(service, version, mode, path + ["load_legacy_particles"])
                            self.project_wall_film_particles_to_film = self.__class__.project_wall_film_particles_to_film(service, version, mode, path + ["project_wall_film_particles_to_film"])
                            self.remove_stuck_particles = self.__class__.remove_stuck_particles(service, version, mode, path + ["remove_stuck_particles"])
                            self.set_film_spreading_parameter = self.__class__.set_film_spreading_parameter(service, version, mode, path + ["set_film_spreading_parameter"])
                            self.set_subtet_intersection_tolerance = self.__class__.set_subtet_intersection_tolerance(service, version, mode, path + ["set_subtet_intersection_tolerance"])
                            self.sliding_interface_crossover_fraction = self.__class__.sliding_interface_crossover_fraction(service, version, mode, path + ["sliding_interface_crossover_fraction"])
                            self.use_barycentric_sampling = self.__class__.use_barycentric_sampling(service, version, mode, path + ["use_barycentric_sampling"])
                            self.use_legacy_particle_location_method = self.__class__.use_legacy_particle_location_method(service, version, mode, path + ["use_legacy_particle_location_method"])
                            self.use_particle_timestep_for_intersection_tolerance = self.__class__.use_particle_timestep_for_intersection_tolerance(service, version, mode, path + ["use_particle_timestep_for_intersection_tolerance"])
                            self.use_quad_face_centroid = self.__class__.use_quad_face_centroid(service, version, mode, path + ["use_quad_face_centroid"])
                            self.use_velocity_based_error_control = self.__class__.use_velocity_based_error_control(service, version, mode, path + ["use_velocity_based_error_control"])
                            self.wallfilm_relocation_tolerance = self.__class__.wallfilm_relocation_tolerance(service, version, mode, path + ["wallfilm_relocation_tolerance"])
                            super().__init__(service, version, mode, path)
                        class always_use_face_centroid_with_periodics(TUIMethod):
                            """
                            .
                            """
                        class boundary_layer_tracking(TUIMethod):
                            """
                            .
                            """
                        class check_subtet_validity(TUIMethod):
                            """
                            .
                            """
                        class enable_automatic_intersection_tolerance(TUIMethod):
                            """
                            .
                            """
                        class enable_barycentric_intersections(TUIMethod):
                            """
                            .
                            """
                        class enable_high_resolution_tracking(TUIMethod):
                            """
                            .
                            """
                        class enhanced_wallfilm_location_method(TUIMethod):
                            """
                            Enable enhanced method of locating film particles on faces.
                            """
                        class load_legacy_particles(TUIMethod):
                            """
                            Load particles that were tracked without high-resolution tracking enabled.
                            """
                        class project_wall_film_particles_to_film(TUIMethod):
                            """
                            Project existing particles to film to track using high resolution tracking?.
                            """
                        class remove_stuck_particles(TUIMethod):
                            """
                            .
                            """
                        class set_film_spreading_parameter(TUIMethod):
                            """
                            Set the spreading parameter for Lagrangian wallfilm particles.
                            """
                        class set_subtet_intersection_tolerance(TUIMethod):
                            """
                            Set the tolerance for subtet intersection calculations.
                            """
                        class sliding_interface_crossover_fraction(TUIMethod):
                            """
                            Move the particle a fraction of the distance to the subtet center when crossing a sliding interface.
                            """
                        class use_barycentric_sampling(TUIMethod):
                            """
                            .
                            """
                        class use_legacy_particle_location_method(TUIMethod):
                            """
                            Enable legacy method of locating particles in cells.
                            """
                        class use_particle_timestep_for_intersection_tolerance(TUIMethod):
                            """
                            Use the particle timestep for the axisymmetric subtet intersection tolerance.
                            """
                        class use_quad_face_centroid(TUIMethod):
                            """
                            .
                            """
                        class use_velocity_based_error_control(TUIMethod):
                            """
                            Use adaptive time stepping based upon the particle velocity.
                            """
                        class wallfilm_relocation_tolerance(TUIMethod):
                            """
                            Set the relocation tolerance for wallfilm particles after remeshing.
                            """

                        class barycentric_interpolation(TUIMenu):
                            """
                            Enter the barycentric interpolation menu.
                            """
                            def __init__(self, service, version, mode, path):
                                self.enable_transient_variable_interpolation = self.__class__.enable_transient_variable_interpolation(service, version, mode, path + ["enable_transient_variable_interpolation"])
                                self.interpolate_flow_cp = self.__class__.interpolate_flow_cp(service, version, mode, path + ["interpolate_flow_cp"])
                                self.interpolate_flow_density = self.__class__.interpolate_flow_density(service, version, mode, path + ["interpolate_flow_density"])
                                self.interpolate_flow_solution_gradients = self.__class__.interpolate_flow_solution_gradients(service, version, mode, path + ["interpolate_flow_solution_gradients"])
                                self.interpolate_flow_viscosity = self.__class__.interpolate_flow_viscosity(service, version, mode, path + ["interpolate_flow_viscosity"])
                                self.interpolate_temperature = self.__class__.interpolate_temperature(service, version, mode, path + ["interpolate_temperature"])
                                self.interpolate_wallfilm_properties = self.__class__.interpolate_wallfilm_properties(service, version, mode, path + ["interpolate_wallfilm_properties"])
                                self.nodal_reconstruction_frequency = self.__class__.nodal_reconstruction_frequency(service, version, mode, path + ["nodal_reconstruction_frequency"])
                                self.precompute_pdf_species = self.__class__.precompute_pdf_species(service, version, mode, path + ["precompute_pdf_species"])
                                self.user_interpolation_function = self.__class__.user_interpolation_function(service, version, mode, path + ["user_interpolation_function"])
                                self.zero_nodal_velocity_on_walls = self.__class__.zero_nodal_velocity_on_walls(service, version, mode, path + ["zero_nodal_velocity_on_walls"])
                                super().__init__(service, version, mode, path)
                            class enable_transient_variable_interpolation(TUIMethod):
                                """
                                Enable transient variable interpolation.
                                """
                            class interpolate_flow_cp(TUIMethod):
                                """
                                .
                                """
                            class interpolate_flow_density(TUIMethod):
                                """
                                .
                                """
                            class interpolate_flow_solution_gradients(TUIMethod):
                                """
                                .
                                """
                            class interpolate_flow_viscosity(TUIMethod):
                                """
                                .
                                """
                            class interpolate_temperature(TUIMethod):
                                """
                                .
                                """
                            class interpolate_wallfilm_properties(TUIMethod):
                                """
                                Enable interpolation of wallfilm properties to the particle position.
                                """
                            class nodal_reconstruction_frequency(TUIMethod):
                                """
                                Update nodal reconstruction every N'th DPM iteration.
                                """
                            class precompute_pdf_species(TUIMethod):
                                """
                                Precompute cell values of PDF species mass fractions prior to particle tracking.
                                """
                            class user_interpolation_function(TUIMethod):
                                """
                                .
                                """
                            class zero_nodal_velocity_on_walls(TUIMethod):
                                """
                                .
                                """

                        class particle_relocation(TUIMenu):
                            """
                            Enter the particle relocation menu.
                            """
                            def __init__(self, service, version, mode, path):
                                self.enhanced_cell_relocation_method = self.__class__.enhanced_cell_relocation_method(service, version, mode, path + ["enhanced_cell_relocation_method"])
                                self.enhanced_wallfilm_location_method = self.__class__.enhanced_wallfilm_location_method(service, version, mode, path + ["enhanced_wallfilm_location_method"])
                                self.load_legacy_particles = self.__class__.load_legacy_particles(service, version, mode, path + ["load_legacy_particles"])
                                self.overset_relocation_robustness_level = self.__class__.overset_relocation_robustness_level(service, version, mode, path + ["overset_relocation_robustness_level"])
                                self.use_legacy_particle_location_method = self.__class__.use_legacy_particle_location_method(service, version, mode, path + ["use_legacy_particle_location_method"])
                                self.wallfilm_relocation_tolerance_scale_factor = self.__class__.wallfilm_relocation_tolerance_scale_factor(service, version, mode, path + ["wallfilm_relocation_tolerance_scale_factor"])
                                super().__init__(service, version, mode, path)
                            class enhanced_cell_relocation_method(TUIMethod):
                                """
                                .
                                """
                            class enhanced_wallfilm_location_method(TUIMethod):
                                """
                                Enable enhanced method of locating film particles on faces.
                                """
                            class load_legacy_particles(TUIMethod):
                                """
                                .
                                """
                            class overset_relocation_robustness_level(TUIMethod):
                                """
                                .
                                """
                            class use_legacy_particle_location_method(TUIMethod):
                                """
                                .
                                """
                            class wallfilm_relocation_tolerance_scale_factor(TUIMethod):
                                """
                                Set the relocation tolerance scaling factor for wallfilm particles after remeshing.
                                """

                class options(TUIMenu):
                    """
                    Enter the options menu to set optional DPM models.
                    """
                    def __init__(self, service, version, mode, path):
                        self.allow_supercritical_pressure_vaporization = self.__class__.allow_supercritical_pressure_vaporization(service, version, mode, path + ["allow_supercritical_pressure_vaporization"])
                        self.brownian_motion = self.__class__.brownian_motion(service, version, mode, path + ["brownian_motion"])
                        self.convective_film_heat_transfer = self.__class__.convective_film_heat_transfer(service, version, mode, path + ["convective_film_heat_transfer"])
                        self.current_positions_in_sample_file_format = self.__class__.current_positions_in_sample_file_format(service, version, mode, path + ["current_positions_in_sample_file_format"])
                        self.enable_contour_plots = self.__class__.enable_contour_plots(service, version, mode, path + ["enable_contour_plots"])
                        self.ensemble_average = self.__class__.ensemble_average(service, version, mode, path + ["ensemble_average"])
                        self.erosion_accretion = self.__class__.erosion_accretion(service, version, mode, path + ["erosion_accretion"])
                        self.film_movement = self.__class__.film_movement(service, version, mode, path + ["film_movement"])
                        self.include_lwf_particles_in_dpm_concentration = self.__class__.include_lwf_particles_in_dpm_concentration(service, version, mode, path + ["include_lwf_particles_in_dpm_concentration"])
                        self.init_erosion_accretion_rate = self.__class__.init_erosion_accretion_rate(service, version, mode, path + ["init_erosion_accretion_rate"])
                        self.lowest_volatiles_mass_fraction = self.__class__.lowest_volatiles_mass_fraction(service, version, mode, path + ["lowest_volatiles_mass_fraction"])
                        self.lwf_continuity_formulation = self.__class__.lwf_continuity_formulation(service, version, mode, path + ["lwf_continuity_formulation"])
                        self.maximum_udf_species = self.__class__.maximum_udf_species(service, version, mode, path + ["maximum_udf_species"])
                        self.particle_radiation = self.__class__.particle_radiation(service, version, mode, path + ["particle_radiation"])
                        self.pressure_gradient_force = self.__class__.pressure_gradient_force(service, version, mode, path + ["pressure_gradient_force"])
                        self.remove_wall_film_temperature_limiter = self.__class__.remove_wall_film_temperature_limiter(service, version, mode, path + ["remove_wall_film_temperature_limiter"])
                        self.saffman_lift_force = self.__class__.saffman_lift_force(service, version, mode, path + ["saffman_lift_force"])
                        self.scr_urea_deposition = self.__class__.scr_urea_deposition(service, version, mode, path + ["scr_urea_deposition"])
                        self.set_minimum_particle_diameter = self.__class__.set_minimum_particle_diameter(service, version, mode, path + ["set_minimum_particle_diameter"])
                        self.set_thermolysis_limit = self.__class__.set_thermolysis_limit(service, version, mode, path + ["set_thermolysis_limit"])
                        self.stagger_radius = self.__class__.stagger_radius(service, version, mode, path + ["stagger_radius"])
                        self.stagger_spatially_atomizer_injections = self.__class__.stagger_spatially_atomizer_injections(service, version, mode, path + ["stagger_spatially_atomizer_injections"])
                        self.stagger_spatially_standard_injections = self.__class__.stagger_spatially_standard_injections(service, version, mode, path + ["stagger_spatially_standard_injections"])
                        self.stagger_temporally = self.__class__.stagger_temporally(service, version, mode, path + ["stagger_temporally"])
                        self.staggering_factor = self.__class__.staggering_factor(service, version, mode, path + ["staggering_factor"])
                        self.step_report_sig_figures = self.__class__.step_report_sig_figures(service, version, mode, path + ["step_report_sig_figures"])
                        self.thermophoretic_force = self.__class__.thermophoretic_force(service, version, mode, path + ["thermophoretic_force"])
                        self.track_in_absolute_frame = self.__class__.track_in_absolute_frame(service, version, mode, path + ["track_in_absolute_frame"])
                        self.treat_multicomponent_saturation_temperature_failure = self.__class__.treat_multicomponent_saturation_temperature_failure(service, version, mode, path + ["treat_multicomponent_saturation_temperature_failure"])
                        self.two_way_coupling = self.__class__.two_way_coupling(service, version, mode, path + ["two_way_coupling"])
                        self.uniform_mass_distribution_for_injections = self.__class__.uniform_mass_distribution_for_injections(service, version, mode, path + ["uniform_mass_distribution_for_injections"])
                        self.use_absolute_pressure_for_vaporization = self.__class__.use_absolute_pressure_for_vaporization(service, version, mode, path + ["use_absolute_pressure_for_vaporization"])
                        self.vaporization_heat_transfer_averaging = self.__class__.vaporization_heat_transfer_averaging(service, version, mode, path + ["vaporization_heat_transfer_averaging"])
                        self.vaporization_options = self.__class__.vaporization_options(service, version, mode, path + ["vaporization_options"])
                        self.virtual_mass_force = self.__class__.virtual_mass_force(service, version, mode, path + ["virtual_mass_force"])
                        super().__init__(service, version, mode, path)
                    class allow_supercritical_pressure_vaporization(TUIMethod):
                        """
                        Skip the pressure dependent boiling point calculation to allow supercritical pressure conditions for vaporization.
                        """
                    class brownian_motion(TUIMethod):
                        """
                        Enable/disable Brownian motion of particles.
                        """
                    class convective_film_heat_transfer(TUIMethod):
                        """
                        Enable/disable convection/conduction film to wall heat transfer model.
                        """
                    class current_positions_in_sample_file_format(TUIMethod):
                        """
                        Write the current positions (step-by-step history report for unsteady tracking) in the sampling file format.
                        """
                    class enable_contour_plots(TUIMethod):
                        """
                        Enable contour and vector plots of particle data.
                        """
                    class ensemble_average(TUIMethod):
                        """
                        Set ensemble average cloud properties.
                        """
                    class erosion_accretion(TUIMethod):
                        """
                        Enable/disable erosion/accretion.
                        """
                    class film_movement(TUIMethod):
                        """
                        .
                        """
                    class include_lwf_particles_in_dpm_concentration(TUIMethod):
                        """
                        .
                        """
                    class init_erosion_accretion_rate(TUIMethod):
                        """
                        Initialize erosion/accretion rates with Zero.
                        """
                    class lowest_volatiles_mass_fraction(TUIMethod):
                        """
                        Set the lowest volatiles mass fraction.
                        """
                    class lwf_continuity_formulation(TUIMethod):
                        """
                        .
                        """
                    class maximum_udf_species(TUIMethod):
                        """
                        .
                        """
                    class particle_radiation(TUIMethod):
                        """
                        Enable/disable particle radiation.
                        """
                    class pressure_gradient_force(TUIMethod):
                        """
                        .
                        """
                    class remove_wall_film_temperature_limiter(TUIMethod):
                        """
                        Remove the wall film temperature limiter.
                        """
                    class saffman_lift_force(TUIMethod):
                        """
                        Enable/disable Saffman lift force.
                        """
                    class scr_urea_deposition(TUIMethod):
                        """
                        Options for urea deposition in SCR simulations.
                        """
                    class set_minimum_particle_diameter(TUIMethod):
                        """
                        Set the minimum particle diameter.
                        """
                    class set_thermolysis_limit(TUIMethod):
                        """
                        Set the thermolysis limit.
                        """
                    class stagger_radius(TUIMethod):
                        """
                        Provide a stagger radius for non atomizer injections.
                        """
                    class stagger_spatially_atomizer_injections(TUIMethod):
                        """
                        Spatially stagger atomizer injections?.
                        """
                    class stagger_spatially_standard_injections(TUIMethod):
                        """
                        Spatially stagger non-atomizer injections?.
                        """
                    class stagger_temporally(TUIMethod):
                        """
                        Stagger transient parcels for their first time step?.
                        """
                    class staggering_factor(TUIMethod):
                        """
                        Set the staggering factor between 0 and 1 to control the amount of staggering.
                        """
                    class step_report_sig_figures(TUIMethod):
                        """
                        Set significant figures in the step-by-step report.
                        """
                    class thermophoretic_force(TUIMethod):
                        """
                        Enable/disable thermophoretic force.
                        """
                    class track_in_absolute_frame(TUIMethod):
                        """
                        Enable/disable tracking in absolute frame.
                        """
                    class treat_multicomponent_saturation_temperature_failure(TUIMethod):
                        """
                        Dump multicomponent particle mass if the saturation temperature cannot be determined.
                        """
                    class two_way_coupling(TUIMethod):
                        """
                        Enable/disable calculation of DPM sources in TKE equation.
                        """
                    class uniform_mass_distribution_for_injections(TUIMethod):
                        """
                        A uniform mass distribution will be enabled for all solid cone and atomizer injections.
                        """
                    class use_absolute_pressure_for_vaporization(TUIMethod):
                        """
                        Enable/disable using Absolute Pressure for Vaporization.
                        """
                    class vaporization_heat_transfer_averaging(TUIMethod):
                        """
                        Enable/disable correction for Vaporization heat transfer.
                        """
                    class vaporization_options(TUIMethod):
                        """
                        Set Vaporization options.
                        """
                    class virtual_mass_force(TUIMethod):
                        """
                        Enable/disable virtual mass force.
                        """

                class parallel(TUIMenu):
                    """
                    Enter the parallel menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                        self.enable_workpile = self.__class__.enable_workpile(service, version, mode, path + ["enable_workpile"])
                        self.fix_source_term_accumulation_order = self.__class__.fix_source_term_accumulation_order(service, version, mode, path + ["fix_source_term_accumulation_order"])
                        self.hybrid_2domain = self.__class__.hybrid_2domain(service, version, mode, path + ["hybrid_2domain"])
                        self.hybrid_collision_model = self.__class__.hybrid_collision_model(service, version, mode, path + ["hybrid_collision_model"])
                        self.hybrid_collision_unidirectional = self.__class__.hybrid_collision_unidirectional(service, version, mode, path + ["hybrid_collision_unidirectional"])
                        self.hybrid_collision_variant = self.__class__.hybrid_collision_variant(service, version, mode, path + ["hybrid_collision_variant"])
                        self.hybrid_workpile = self.__class__.hybrid_workpile(service, version, mode, path + ["hybrid_workpile"])
                        self.n_threads = self.__class__.n_threads(service, version, mode, path + ["n_threads"])
                        self.report = self.__class__.report(service, version, mode, path + ["report"])
                        self.use_hybrid = self.__class__.use_hybrid(service, version, mode, path + ["use_hybrid"])
                        self.use_message_passing = self.__class__.use_message_passing(service, version, mode, path + ["use_message_passing"])
                        self.use_shared_memory = self.__class__.use_shared_memory(service, version, mode, path + ["use_shared_memory"])
                        super().__init__(service, version, mode, path)
                    class enable_workpile(TUIMethod):
                        """
                        Enable/disable the particle workpile algorithm.
                        """
                    class fix_source_term_accumulation_order(TUIMethod):
                        """
                        .
                        """
                    class hybrid_2domain(TUIMethod):
                        """
                        .
                        """
                    class hybrid_collision_model(TUIMethod):
                        """
                        An EXPERIMENTAL feature to allow 'hybrid' DPM parallel tracking with the collision / coalescence model.
                        """
                    class hybrid_collision_unidirectional(TUIMethod):
                        """
                        A faster, yet potentially somewhat less accurate, modification to the beta feature
                        that allows 'hybrid' DPM parallel tracking with the collision / coalescence model.
                        """
                    class hybrid_collision_variant(TUIMethod):
                        """
                        Further reduce the residual risk of dead-locks in the experimental feature that
                        allows 'hybrid' DPM parallel tracking with the collision / coalescence model.
                        """
                    class hybrid_workpile(TUIMethod):
                        """
                        Optimize multi-thread load balancing within each partition in hybrid-parallel DPM tracking.
                        """
                    class n_threads(TUIMethod):
                        """
                        Set the number of processors to use for DPM.
                        """
                    class report(TUIMethod):
                        """
                        Print particle workpile statistics.
                        """
                    class use_hybrid(TUIMethod):
                        """
                        Set DPM parallel-mode to hybrid.
                        """
                    class use_message_passing(TUIMethod):
                        """
                        Set DPM parallel-mode to message passing.
                        """
                    class use_shared_memory(TUIMethod):
                        """
                        Set DPM parallel-mode to shared memory.
                        """

                    class expert(TUIMenu):
                        """
                        Enter the menu to set expert DPM parallel options.
                        """
                        def __init__(self, service, version, mode, path):
                            self.partition_method_hybrid_2domain = self.__class__.partition_method_hybrid_2domain(service, version, mode, path + ["partition_method_hybrid_2domain"])
                            super().__init__(service, version, mode, path)
                        class partition_method_hybrid_2domain(TUIMethod):
                            """
                            Set DPM Domain partition method.
                            """

                class splash_options(TUIMenu):
                    """
                    Enter the splash options menu to set optional parameters.
                    """
                    def __init__(self, service, version, mode, path):
                        self.orourke_splash_fraction = self.__class__.orourke_splash_fraction(service, version, mode, path + ["orourke_splash_fraction"])
                        self.splash_pdf_limiting = self.__class__.splash_pdf_limiting(service, version, mode, path + ["splash_pdf_limiting"])
                        super().__init__(service, version, mode, path)
                    class orourke_splash_fraction(TUIMethod):
                        """
                        Select splash fraction method.
                        """
                    class splash_pdf_limiting(TUIMethod):
                        """
                        Select splash pdf limiting method.
                        """

                class stripping_options(TUIMenu):
                    """
                    Enter the stripping options menu to set optional parameters.
                    """
                    def __init__(self, service, version, mode, path):
                        self.diameter_coefficient = self.__class__.diameter_coefficient(service, version, mode, path + ["diameter_coefficient"])
                        self.mass_coefficient = self.__class__.mass_coefficient(service, version, mode, path + ["mass_coefficient"])
                        super().__init__(service, version, mode, path)
                    class diameter_coefficient(TUIMethod):
                        """
                        Set the stripping diameter coefficient.
                        """
                    class mass_coefficient(TUIMethod):
                        """
                        Set the stripping mass coefficient.
                        """

            class electrolysis_setup(TUIMenu):
                """
                Enter the electrolysis and H2 pump model setup menu.
                """
                def __init__(self, service, version, mode, path):
                    self.advanced_setup = self.__class__.advanced_setup(service, version, mode, path + ["advanced_setup"])
                    self.anode_setup = self.__class__.anode_setup(service, version, mode, path + ["anode_setup"])
                    self.cathode_setup = self.__class__.cathode_setup(service, version, mode, path + ["cathode_setup"])
                    self.membrane_setup = self.__class__.membrane_setup(service, version, mode, path + ["membrane_setup"])
                    self.customization = self.__class__.customization(service, version, mode, path + ["customization"])
                    self.electrical_tabs_setup = self.__class__.electrical_tabs_setup(service, version, mode, path + ["electrical_tabs_setup"])
                    self.model_options = self.__class__.model_options(service, version, mode, path + ["model_options"])
                    self.parameters = self.__class__.parameters(service, version, mode, path + ["parameters"])
                    super().__init__(service, version, mode, path)
                class customization(TUIMethod):
                    """
                    Customization of electrolysis model.
                    """
                class electrical_tabs_setup(TUIMethod):
                    """
                    Specify settings for the electrical tabs.
                    """
                class model_options(TUIMethod):
                    """
                    Specify electrolysis model options.
                    """
                class parameters(TUIMethod):
                    """
                    Specify electrolysis model parameters.
                    """

                class advanced_setup(TUIMenu):
                    """
                    Enter the menu for the advanced controls.
                    """
                    def __init__(self, service, version, mode, path):
                        self.contact_resistivity = self.__class__.contact_resistivity(service, version, mode, path + ["contact_resistivity"])
                        super().__init__(service, version, mode, path)
                    class contact_resistivity(TUIMethod):
                        """
                        Set Contact Resistivity.
                        """

                class anode_setup(TUIMenu):
                    """
                    Enter the menu for the anode controls.
                    """
                    def __init__(self, service, version, mode, path):
                        self.catalyst_layer = self.__class__.catalyst_layer(service, version, mode, path + ["catalyst_layer"])
                        self.current_collector = self.__class__.current_collector(service, version, mode, path + ["current_collector"])
                        self.electrolyte = self.__class__.electrolyte(service, version, mode, path + ["electrolyte"])
                        self.flow_channel = self.__class__.flow_channel(service, version, mode, path + ["flow_channel"])
                        self.porous_layer = self.__class__.porous_layer(service, version, mode, path + ["porous_layer"])
                        super().__init__(service, version, mode, path)
                    class catalyst_layer(TUIMethod):
                        """
                        Set parameters for the catalyst layer.
                        """
                    class current_collector(TUIMethod):
                        """
                        Set parameters for the current collector.
                        """
                    class electrolyte(TUIMethod):
                        """
                        Set parameters for the electrolyte.
                        """
                    class flow_channel(TUIMethod):
                        """
                        Set parameters for the flow channel.
                        """
                    class porous_layer(TUIMethod):
                        """
                        Set parameters for the porous layer.
                        """

                class cathode_setup(TUIMenu):
                    """
                    Enter the menu for the cathode controls.
                    """
                    def __init__(self, service, version, mode, path):
                        self.catalyst_layer = self.__class__.catalyst_layer(service, version, mode, path + ["catalyst_layer"])
                        self.current_collector = self.__class__.current_collector(service, version, mode, path + ["current_collector"])
                        self.electrolyte = self.__class__.electrolyte(service, version, mode, path + ["electrolyte"])
                        self.flow_channel = self.__class__.flow_channel(service, version, mode, path + ["flow_channel"])
                        self.porous_layer = self.__class__.porous_layer(service, version, mode, path + ["porous_layer"])
                        super().__init__(service, version, mode, path)
                    class catalyst_layer(TUIMethod):
                        """
                        Set parameters for the catalyst layer.
                        """
                    class current_collector(TUIMethod):
                        """
                        Set parameters for the current collector.
                        """
                    class electrolyte(TUIMethod):
                        """
                        Set parameters for the electrolyte.
                        """
                    class flow_channel(TUIMethod):
                        """
                        Set parameters for the flow channel.
                        """
                    class porous_layer(TUIMethod):
                        """
                        Set parameters for the porous layer.
                        """

                class membrane_setup(TUIMenu):
                    """
                    Specify parameters for electrolyte.
                    """
                    def __init__(self, service, version, mode, path):
                        self.catalyst_layer = self.__class__.catalyst_layer(service, version, mode, path + ["catalyst_layer"])
                        self.current_collector = self.__class__.current_collector(service, version, mode, path + ["current_collector"])
                        self.electrolyte = self.__class__.electrolyte(service, version, mode, path + ["electrolyte"])
                        self.flow_channel = self.__class__.flow_channel(service, version, mode, path + ["flow_channel"])
                        self.porous_layer = self.__class__.porous_layer(service, version, mode, path + ["porous_layer"])
                        super().__init__(service, version, mode, path)
                    class catalyst_layer(TUIMethod):
                        """
                        Set parameters for the catalyst layer.
                        """
                    class current_collector(TUIMethod):
                        """
                        Set parameters for the current collector.
                        """
                    class electrolyte(TUIMethod):
                        """
                        Set parameters for the electrolyte.
                        """
                    class flow_channel(TUIMethod):
                        """
                        Set parameters for the flow channel.
                        """
                    class porous_layer(TUIMethod):
                        """
                        Set parameters for the porous layer.
                        """

            class eulerian_wallfilm(TUIMenu):
                """
                Enter the Eulerian wall film model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.coupled_solution = self.__class__.coupled_solution(service, version, mode, path + ["coupled_solution"])
                    self.implicit_options = self.__class__.implicit_options(service, version, mode, path + ["implicit_options"])
                    self.enable_film_nci_support = self.__class__.enable_film_nci_support(service, version, mode, path + ["enable_film_nci_support"])
                    self.enable_film_vof_transition_message = self.__class__.enable_film_vof_transition_message(service, version, mode, path + ["enable_film_vof_transition_message"])
                    self.enable_wallfilm_model = self.__class__.enable_wallfilm_model(service, version, mode, path + ["enable_wallfilm_model"])
                    self.film_material = self.__class__.film_material(service, version, mode, path + ["film_material"])
                    self.initialize_wallfilm_model = self.__class__.initialize_wallfilm_model(service, version, mode, path + ["initialize_wallfilm_model"])
                    self.list_film_walls = self.__class__.list_film_walls(service, version, mode, path + ["list_film_walls"])
                    self.model_options = self.__class__.model_options(service, version, mode, path + ["model_options"])
                    self.solution_options = self.__class__.solution_options(service, version, mode, path + ["solution_options"])
                    self.solve_wallfilm_equation = self.__class__.solve_wallfilm_equation(service, version, mode, path + ["solve_wallfilm_equation"])
                    super().__init__(service, version, mode, path)
                class enable_film_nci_support(TUIMethod):
                    """
                    Enable wall film NCI support.
                    """
                class enable_film_vof_transition_message(TUIMethod):
                    """
                    Enable film-VOF transition message.
                    """
                class enable_wallfilm_model(TUIMethod):
                    """
                    Enable Eulerian wall film model.
                    """
                class film_material(TUIMethod):
                    """
                    Set film material and properties.
                    """
                class initialize_wallfilm_model(TUIMethod):
                    """
                    Initialize Eulerian wall film model.
                    """
                class list_film_walls(TUIMethod):
                    """
                    List film walls.
                    """
                class model_options(TUIMethod):
                    """
                    Set Eulerian wall film model options.
                    """
                class solution_options(TUIMethod):
                    """
                    Set Eulerian wall film model solution options.
                    """
                class solve_wallfilm_equation(TUIMethod):
                    """
                    Activate Eulerian wall film equations.
                    """

                class coupled_solution(TUIMenu):
                    """
                    Enter Eulerian wall film coupled solution menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.enable_coupled_solution = self.__class__.enable_coupled_solution(service, version, mode, path + ["enable_coupled_solution"])
                        self.enable_curvature_smoothing = self.__class__.enable_curvature_smoothing(service, version, mode, path + ["enable_curvature_smoothing"])
                        super().__init__(service, version, mode, path)
                    class enable_coupled_solution(TUIMethod):
                        """
                        Enable Eulerian wall film coupled solution.
                        """
                    class enable_curvature_smoothing(TUIMethod):
                        """
                        Enable Eulerian wall film curvature smoothing.
                        """

                class implicit_options(TUIMenu):
                    """
                    Enter Implicit Scheme Option (beta).
                    """
                    def __init__(self, service, version, mode, path):
                        self.new_implicit_scheme = self.__class__.new_implicit_scheme(service, version, mode, path + ["new_implicit_scheme"])
                        self.relative_error_residual = self.__class__.relative_error_residual(service, version, mode, path + ["relative_error_residual"])
                        super().__init__(service, version, mode, path)
                    class new_implicit_scheme(TUIMethod):
                        """
                        Enable alternative implicit scheme.
                        """
                    class relative_error_residual(TUIMethod):
                        """
                        Enable relative error residual.
                        """

            class heat_exchanger(TUIMenu):
                """
                Enter the heat exchanger menu.
                """
                def __init__(self, service, version, mode, path):
                    self.dual_cell_model = self.__class__.dual_cell_model(service, version, mode, path + ["dual_cell_model"])
                    self.macro_model = self.__class__.macro_model(service, version, mode, path + ["macro_model"])
                    super().__init__(service, version, mode, path)

                class dual_cell_model(TUIMenu):
                    """
                    Enter the dual cell model menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.add_heat_exchanger = self.__class__.add_heat_exchanger(service, version, mode, path + ["add_heat_exchanger"])
                        self.alternative_formulation = self.__class__.alternative_formulation(service, version, mode, path + ["alternative_formulation"])
                        self.delete_heat_exchanger = self.__class__.delete_heat_exchanger(service, version, mode, path + ["delete_heat_exchanger"])
                        self.heat_exchanger = self.__class__.heat_exchanger(service, version, mode, path + ["heat_exchanger"])
                        self.modify_heat_exchanger = self.__class__.modify_heat_exchanger(service, version, mode, path + ["modify_heat_exchanger"])
                        self.plot_NTU = self.__class__.plot_NTU(service, version, mode, path + ["plot_NTU"])
                        self.write_NTU = self.__class__.write_NTU(service, version, mode, path + ["write_NTU"])
                        super().__init__(service, version, mode, path)
                    class add_heat_exchanger(TUIMethod):
                        """
                        Add heat-exchanger.
                        """
                    class alternative_formulation(TUIMethod):
                        """
                        Enable/disable alternative formulation for heat transfer calculations.
                        """
                    class delete_heat_exchanger(TUIMethod):
                        """
                        Delete heat-exchanger.
                        """
                    class heat_exchanger(TUIMethod):
                        """
                        Enable/disable the dual cell heat-exchanger model.
                        """
                    class modify_heat_exchanger(TUIMethod):
                        """
                        Modify heat-exchanger.
                        """
                    class plot_NTU(TUIMethod):
                        """
                        Plot NTU vs primary mass flow rate for each auxiliary mass flow rate.
                        """
                    class write_NTU(TUIMethod):
                        """
                        Write NTU vs primary mass flow rate for each auxiliary mass flow rate.
                        """

                class macro_model(TUIMenu):
                    """
                    Enter the heat macro-model menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.delete_heat_exchanger_group = self.__class__.delete_heat_exchanger_group(service, version, mode, path + ["delete_heat_exchanger_group"])
                        self.heat_exchanger = self.__class__.heat_exchanger(service, version, mode, path + ["heat_exchanger"])
                        self.heat_exchanger_group = self.__class__.heat_exchanger_group(service, version, mode, path + ["heat_exchanger_group"])
                        self.heat_exchanger_macro_report = self.__class__.heat_exchanger_macro_report(service, version, mode, path + ["heat_exchanger_macro_report"])
                        self.heat_exchanger_model = self.__class__.heat_exchanger_model(service, version, mode, path + ["heat_exchanger_model"])
                        self.heat_exchanger_report = self.__class__.heat_exchanger_report(service, version, mode, path + ["heat_exchanger_report"])
                        self.heat_exchanger_zone = self.__class__.heat_exchanger_zone(service, version, mode, path + ["heat_exchanger_zone"])
                        self.plot_NTU = self.__class__.plot_NTU(service, version, mode, path + ["plot_NTU"])
                        self.write_NTU = self.__class__.write_NTU(service, version, mode, path + ["write_NTU"])
                        super().__init__(service, version, mode, path)
                    class delete_heat_exchanger_group(TUIMethod):
                        """
                        Delete heat-exchanger group.
                        """
                    class heat_exchanger(TUIMethod):
                        """
                        Enable/disable heat-exchanger model.
                        """
                    class heat_exchanger_group(TUIMethod):
                        """
                        Define heat-exchanger group.
                        """
                    class heat_exchanger_macro_report(TUIMethod):
                        """
                        Report heat-exchanger information for all the macros.
                        """
                    class heat_exchanger_model(TUIMethod):
                        """
                        Define heat-exchanger core model.
                        """
                    class heat_exchanger_report(TUIMethod):
                        """
                        Report heat-exchanger information.
                        """
                    class heat_exchanger_zone(TUIMethod):
                        """
                        Define heat-exchanger zone.
                        """
                    class plot_NTU(TUIMethod):
                        """
                        Plot NTU vs primary mass flow rate for each auxiliary mass flow rate.
                        """
                    class write_NTU(TUIMethod):
                        """
                        Write NTU vs primary mass flow rate for each auxiliary mass flow rate.
                        """

            class multiphase(TUIMenu):
                """
                Define multiphase model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.explicit_expert_options = self.__class__.explicit_expert_options(service, version, mode, path + ["explicit_expert_options"])
                    self.flow_regime_modeling = self.__class__.flow_regime_modeling(service, version, mode, path + ["flow_regime_modeling"])
                    self.hybrid_models = self.__class__.hybrid_models(service, version, mode, path + ["hybrid_models"])
                    self.population_balance = self.__class__.population_balance(service, version, mode, path + ["population_balance"])
                    self.sub_models = self.__class__.sub_models(service, version, mode, path + ["sub_models"])
                    self.volume_fraction_parameters = self.__class__.volume_fraction_parameters(service, version, mode, path + ["volume_fraction_parameters"])
                    self.wet_steam = self.__class__.wet_steam(service, version, mode, path + ["wet_steam"])
                    self.body_force_formulation = self.__class__.body_force_formulation(service, version, mode, path + ["body_force_formulation"])
                    self.boiling_model_options = self.__class__.boiling_model_options(service, version, mode, path + ["boiling_model_options"])
                    self.coupled_level_set = self.__class__.coupled_level_set(service, version, mode, path + ["coupled_level_set"])
                    self.eulerian_parameters = self.__class__.eulerian_parameters(service, version, mode, path + ["eulerian_parameters"])
                    self.expert_options = self.__class__.expert_options(service, version, mode, path + ["expert_options"])
                    self.interface_modeling_options = self.__class__.interface_modeling_options(service, version, mode, path + ["interface_modeling_options"])
                    self.mixture_parameters = self.__class__.mixture_parameters(service, version, mode, path + ["mixture_parameters"])
                    self.model = self.__class__.model(service, version, mode, path + ["model"])
                    self.number_of_phases = self.__class__.number_of_phases(service, version, mode, path + ["number_of_phases"])
                    self.regime_transition_modeling = self.__class__.regime_transition_modeling(service, version, mode, path + ["regime_transition_modeling"])
                    self.vof_sub_models = self.__class__.vof_sub_models(service, version, mode, path + ["vof_sub_models"])
                    super().__init__(service, version, mode, path)
                class body_force_formulation(TUIMethod):
                    """
                    .
                    """
                class boiling_model_options(TUIMethod):
                    """
                    Boiling model options.
                    """
                class coupled_level_set(TUIMethod):
                    """
                    .
                    """
                class eulerian_parameters(TUIMethod):
                    """
                    Eulerian parameters.
                    """
                class expert_options(TUIMethod):
                    """
                    Expert Options.
                    """
                class interface_modeling_options(TUIMethod):
                    """
                    .
                    """
                class mixture_parameters(TUIMethod):
                    """
                    Mixture parameters.
                    """
                class model(TUIMethod):
                    """
                    .
                    """
                class number_of_phases(TUIMethod):
                    """
                    Specify the number of phases.
                    """
                class regime_transition_modeling(TUIMethod):
                    """
                    Regime-transition-modeling-options.
                    """
                class vof_sub_models(TUIMethod):
                    """
                    .
                    """

                class explicit_expert_options(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.volume_fraction_filtering = self.__class__.volume_fraction_filtering(service, version, mode, path + ["volume_fraction_filtering"])
                        self.solve_vof_every_iter = self.__class__.solve_vof_every_iter(service, version, mode, path + ["solve_vof_every_iter"])
                        self.sub_time_step_method = self.__class__.sub_time_step_method(service, version, mode, path + ["sub_time_step_method"])
                        super().__init__(service, version, mode, path)
                    class solve_vof_every_iter(TUIMethod):
                        """
                        .
                        """
                    class sub_time_step_method(TUIMethod):
                        """
                        .
                        """

                    class volume_fraction_filtering(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                            self.filtering_options = self.__class__.filtering_options(service, version, mode, path + ["filtering_options"])
                            self.vol_frac_cutoff = self.__class__.vol_frac_cutoff(service, version, mode, path + ["vol_frac_cutoff"])
                            super().__init__(service, version, mode, path)
                        class enable(TUIMethod):
                            """
                            .
                            """
                        class filtering_options(TUIMethod):
                            """
                            .
                            """
                        class vol_frac_cutoff(TUIMethod):
                            """
                            .
                            """

                class flow_regime_modeling(TUIMenu):
                    """
                    Flow Regime Modeling.
                    """
                    def __init__(self, service, version, mode, path):
                        self.aiad_parameters = self.__class__.aiad_parameters(service, version, mode, path + ["aiad_parameters"])
                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                        super().__init__(service, version, mode, path)
                    class enable(TUIMethod):
                        """
                        Enable flow regime modeling framework including phase state and morphology.
                        """

                    class aiad_parameters(TUIMenu):
                        """
                        AIAD parameters.
                        """
                        def __init__(self, service, version, mode, path):
                            self.critical_vf = self.__class__.critical_vf(service, version, mode, path + ["critical_vf"])
                            self.delta_grad = self.__class__.delta_grad(service, version, mode, path + ["delta_grad"])
                            self.delta_vf = self.__class__.delta_vf(service, version, mode, path + ["delta_vf"])
                            self.ncells_fs = self.__class__.ncells_fs(service, version, mode, path + ["ncells_fs"])
                            super().__init__(service, version, mode, path)
                        class critical_vf(TUIMethod):
                            """
                            Critical volume fraction for bubbly and droplet flow blending factors.
                            """
                        class delta_grad(TUIMethod):
                            """
                            Parameter for determining transition width for free surface blending factor.
                            """
                        class delta_vf(TUIMethod):
                            """
                            Parameter for transition width for bubbly and droplet flow blending factors.
                            """
                        class ncells_fs(TUIMethod):
                            """
                            Parameter for determining interfacial width.
                            """

                class hybrid_models(TUIMenu):
                    """
                    Enter the menu to select hybrid models.
                    """
                    def __init__(self, service, version, mode, path):
                        self.ddpm = self.__class__.ddpm(service, version, mode, path + ["ddpm"])
                        self.multi_fluid_vof = self.__class__.multi_fluid_vof(service, version, mode, path + ["multi_fluid_vof"])
                        super().__init__(service, version, mode, path)
                    class ddpm(TUIMethod):
                        """
                        Enable the dense discrete phase model.
                        """
                    class multi_fluid_vof(TUIMethod):
                        """
                        Enable the multi-fluid VOF model.
                        """

                class population_balance(TUIMenu):
                    """
                    Enter the population balance model menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                        self.phenomena = self.__class__.phenomena(service, version, mode, path + ["phenomena"])
                        self.include_expansion = self.__class__.include_expansion(service, version, mode, path + ["include_expansion"])
                        self.model = self.__class__.model(service, version, mode, path + ["model"])
                        self.size_calculator = self.__class__.size_calculator(service, version, mode, path + ["size_calculator"])
                        super().__init__(service, version, mode, path)
                    class include_expansion(TUIMethod):
                        """
                        Set expansion.
                        """
                    class model(TUIMethod):
                        """
                        Select the population balance model.
                        """
                    class size_calculator(TUIMethod):
                        """
                        Calculate fluid particle diameters using different methods.
                        """

                    class expert(TUIMenu):
                        """
                        Enter the expert menu for quadrature-based population balance method.
                        """
                        def __init__(self, service, version, mode, path):
                            self.qbmm = self.__class__.qbmm(service, version, mode, path + ["qbmm"])
                            self.qmom = self.__class__.qmom(service, version, mode, path + ["qmom"])
                            super().__init__(service, version, mode, path)

                        class qbmm(TUIMenu):
                            """
                            Enter the menu for the quadrature-based moments method based on the Zeta kinetic scheme.
                            """
                            def __init__(self, service, version, mode, path):
                                self.advection_cfl = self.__class__.advection_cfl(service, version, mode, path + ["advection_cfl"])
                                self.advection_cfl_factor = self.__class__.advection_cfl_factor(service, version, mode, path + ["advection_cfl_factor"])
                                self.advection_cfl_method = self.__class__.advection_cfl_method(service, version, mode, path + ["advection_cfl_method"])
                                self.advection_int_max_steps = self.__class__.advection_int_max_steps(service, version, mode, path + ["advection_int_max_steps"])
                                self.advection_int_scheme = self.__class__.advection_int_scheme(service, version, mode, path + ["advection_int_scheme"])
                                self.exit_on_non_real = self.__class__.exit_on_non_real(service, version, mode, path + ["exit_on_non_real"])
                                self.max_volume_fraction = self.__class__.max_volume_fraction(service, version, mode, path + ["max_volume_fraction"])
                                self.min_mass_cutoff = self.__class__.min_mass_cutoff(service, version, mode, path + ["min_mass_cutoff"])
                                self.min_volume_fraction_cutoff = self.__class__.min_volume_fraction_cutoff(service, version, mode, path + ["min_volume_fraction_cutoff"])
                                self.redistribute_moments_based_on_volume_fraction = self.__class__.redistribute_moments_based_on_volume_fraction(service, version, mode, path + ["redistribute_moments_based_on_volume_fraction"])
                                self.redistribution_error = self.__class__.redistribution_error(service, version, mode, path + ["redistribution_error"])
                                self.redistribution_max_iteration = self.__class__.redistribution_max_iteration(service, version, mode, path + ["redistribution_max_iteration"])
                                self.replace_negative_moments = self.__class__.replace_negative_moments(service, version, mode, path + ["replace_negative_moments"])
                                self.solve_advection = self.__class__.solve_advection(service, version, mode, path + ["solve_advection"])
                                self.solve_hydrodynamic_sources = self.__class__.solve_hydrodynamic_sources(service, version, mode, path + ["solve_hydrodynamic_sources"])
                                self.solve_two_fluid_model = self.__class__.solve_two_fluid_model(service, version, mode, path + ["solve_two_fluid_model"])
                                self.sort_abscissas = self.__class__.sort_abscissas(service, version, mode, path + ["sort_abscissas"])
                                self.source_err_abs = self.__class__.source_err_abs(service, version, mode, path + ["source_err_abs"])
                                self.source_err_rel = self.__class__.source_err_rel(service, version, mode, path + ["source_err_rel"])
                                self.source_int_scheme = self.__class__.source_int_scheme(service, version, mode, path + ["source_int_scheme"])
                                self.source_int_time_steps_report = self.__class__.source_int_time_steps_report(service, version, mode, path + ["source_int_time_steps_report"])
                                self.source_min_dt = self.__class__.source_min_dt(service, version, mode, path + ["source_min_dt"])
                                self.source_time_factor = self.__class__.source_time_factor(service, version, mode, path + ["source_time_factor"])
                                self.source_time_factor_max = self.__class__.source_time_factor_max(service, version, mode, path + ["source_time_factor_max"])
                                self.source_time_factor_min = self.__class__.source_time_factor_min(service, version, mode, path + ["source_time_factor_min"])
                                self.update_moments_from_zetas = self.__class__.update_moments_from_zetas(service, version, mode, path + ["update_moments_from_zetas"])
                                self.velocity_of_moments_interpolation = self.__class__.velocity_of_moments_interpolation(service, version, mode, path + ["velocity_of_moments_interpolation"])
                                self.verbosity_level = self.__class__.verbosity_level(service, version, mode, path + ["verbosity_level"])
                                self.zero_moment_minus = self.__class__.zero_moment_minus(service, version, mode, path + ["zero_moment_minus"])
                                self.zero_moment_plus = self.__class__.zero_moment_plus(service, version, mode, path + ["zero_moment_plus"])
                                self.zero_zeta_minus = self.__class__.zero_zeta_minus(service, version, mode, path + ["zero_zeta_minus"])
                                self.zero_zeta_plus = self.__class__.zero_zeta_plus(service, version, mode, path + ["zero_zeta_plus"])
                                super().__init__(service, version, mode, path)
                            class advection_cfl(TUIMethod):
                                """
                                Specify the advection Courant number.
                                """
                            class advection_cfl_factor(TUIMethod):
                                """
                                Specify the blending coefficient of the Courant number calculation for the hybrid method.
                                """
                            class advection_cfl_method(TUIMethod):
                                """
                                Specify the advection Courant number calculation method:
                                0 = flux-based
                                1 = averaged flux-based
                                2 = hybrid flux-based
                                3 = max flux-based
                                4 = same as explicit vof (if available).
                                """
                            class advection_int_max_steps(TUIMethod):
                                """
                                Specify the maximum number of advection time steps.
                                """
                            class advection_int_scheme(TUIMethod):
                                """
                                Specify the advection time integration scheme, 1=Euler, 2=SSP-RK2, 3=SSP-RK3, 4=RK4.
                                """
                            class exit_on_non_real(TUIMethod):
                                """
                                Exit on non-realizable moments detection.
                                """
                            class max_volume_fraction(TUIMethod):
                                """
                                Specify the maximum volume fraction value above which the moments are redistributed.
                                """
                            class min_mass_cutoff(TUIMethod):
                                """
                                Specify the minimum dispersed-phase mass value below which the moments are considered negligible.
                                """
                            class min_volume_fraction_cutoff(TUIMethod):
                                """
                                Specify the minimum volume fraction value below which the moments are considered negligible.
                                """
                            class redistribute_moments_based_on_volume_fraction(TUIMethod):
                                """
                                Redistribute the moments if the volume fraction based on moment-3 is more than ''max-volume-fraction''?.
                                """
                            class redistribution_error(TUIMethod):
                                """
                                Specify the error of the moment-based volume fraction redistribution relative to the total dispersed phase volume.
                                """
                            class redistribution_max_iteration(TUIMethod):
                                """
                                Specify the maximum number of moments redistribution iteration.
                                """
                            class replace_negative_moments(TUIMethod):
                                """
                                Replace negative moments with locally averaged moments.
                                """
                            class solve_advection(TUIMethod):
                                """
                                Solve the advection part of the QBMM equation?.
                                """
                            class solve_hydrodynamic_sources(TUIMethod):
                                """
                                Solve the hydrodynamic interatction sources for each size class.
                                """
                            class solve_two_fluid_model(TUIMethod):
                                """
                                Solve the two-fluid model for the effect of the drift velocity advection on the bulk flow.
                                """
                            class sort_abscissas(TUIMethod):
                                """
                                Sort quadrature points based on abscissas.
                                """
                            class source_err_abs(TUIMethod):
                                """
                                Specify the absolute error for the time intefration of the source terms.
                                """
                            class source_err_rel(TUIMethod):
                                """
                                Specify the relative error for the time integration of the source terms.
                                """
                            class source_int_scheme(TUIMethod):
                                """
                                Specify the embedded time integration scheme for the source terms:
                                2 = 1st-order time integration and 2nd-order error estimation
                                3 = 2nd-order time integration and 3rd-order error estimation
                                .
                                """
                            class source_int_time_steps_report(TUIMethod):
                                """
                                Report the distribution of the source integration time steps based on pre-defined bin sizes.
                                """
                            class source_min_dt(TUIMethod):
                                """
                                Specify the minimum time step for the integration of source terms.
                                """
                            class source_time_factor(TUIMethod):
                                """
                                Specify the time factor for the time integration of the sources.
                                """
                            class source_time_factor_max(TUIMethod):
                                """
                                Specify the maximum time factor for the time integration of the sources.
                                """
                            class source_time_factor_min(TUIMethod):
                                """
                                Specify the minimum time factor for the time integration of the sources.
                                """
                            class update_moments_from_zetas(TUIMethod):
                                """
                                Update moments based on the auxiliary zeta quantities in advection solution?.
                                """
                            class velocity_of_moments_interpolation(TUIMethod):
                                """
                                Specify the interpolation method for the size-class velocity at cell faces:
                                0 = cell-center average
                                1 = upwind.
                                """
                            class verbosity_level(TUIMethod):
                                """
                                Specify a verbosity level (0-4) for QBMM.
                                """
                            class zero_moment_minus(TUIMethod):
                                """
                                Specify a small negative value above which the moments are considered negligible.
                                """
                            class zero_moment_plus(TUIMethod):
                                """
                                Specify a small positive value below which the moments are considered negligible.
                                """
                            class zero_zeta_minus(TUIMethod):
                                """
                                Specify a small negative value above which the auxiliary quantities are considered negligible.
                                """
                            class zero_zeta_plus(TUIMethod):
                                """
                                Specify a small positive value below which the auxiliary quantities are considered negligible.
                                """

                        class qmom(TUIMenu):
                            """
                            Enter the menu for the QMOM.
                            """
                            def __init__(self, service, version, mode, path):
                                self.inversion_algorithm = self.__class__.inversion_algorithm(service, version, mode, path + ["inversion_algorithm"])
                                self.print_realizable_moment_warning = self.__class__.print_realizable_moment_warning(service, version, mode, path + ["print_realizable_moment_warning"])
                                self.realizable_moments = self.__class__.realizable_moments(service, version, mode, path + ["realizable_moments"])
                                self.retain_qmom_sources_for_low_vof = self.__class__.retain_qmom_sources_for_low_vof(service, version, mode, path + ["retain_qmom_sources_for_low_vof"])
                                super().__init__(service, version, mode, path)
                            class inversion_algorithm(TUIMethod):
                                """
                                Select the inversion algorithm for quadrature-based population balance method.
                                """
                            class print_realizable_moment_warning(TUIMethod):
                                """
                                Print the information for realizable moments in the population balance model.
                                """
                            class realizable_moments(TUIMethod):
                                """
                                Set the population balance model.
                                """
                            class retain_qmom_sources_for_low_vof(TUIMethod):
                                """
                                Retain qmom source calculation for low secondary phase vof.
                                """

                    class phenomena(TUIMenu):
                        """
                        Enter the phenomena menu for population balance.
                        """
                        def __init__(self, service, version, mode, path):
                            self.aggregation = self.__class__.aggregation(service, version, mode, path + ["aggregation"])
                            self.aggregation_factor = self.__class__.aggregation_factor(service, version, mode, path + ["aggregation_factor"])
                            self.breakage = self.__class__.breakage(service, version, mode, path + ["breakage"])
                            self.breakage_aggregation_vof_cutoff = self.__class__.breakage_aggregation_vof_cutoff(service, version, mode, path + ["breakage_aggregation_vof_cutoff"])
                            self.breakage_factor = self.__class__.breakage_factor(service, version, mode, path + ["breakage_factor"])
                            self.growth = self.__class__.growth(service, version, mode, path + ["growth"])
                            self.nucleation = self.__class__.nucleation(service, version, mode, path + ["nucleation"])
                            super().__init__(service, version, mode, path)
                        class aggregation(TUIMethod):
                            """
                            Set the aggregation kernel.
                            """
                        class aggregation_factor(TUIMethod):
                            """
                            Set a factor which controls the intensity of the selected aggregation kernel.
                            """
                        class breakage(TUIMethod):
                            """
                            Set the breakage kernel.
                            """
                        class breakage_aggregation_vof_cutoff(TUIMethod):
                            """
                            Control vof cut-off for breakage and aggregation.
                            """
                        class breakage_factor(TUIMethod):
                            """
                            Set a factor which controls the intensity of the selected breakage kernel.
                            """
                        class growth(TUIMethod):
                            """
                            Set the growth rate.
                            """
                        class nucleation(TUIMethod):
                            """
                            Set the nucleantion rate.
                            """

                class sub_models(TUIMenu):
                    """
                    Enter the menu to select sub-models.
                    """
                    def __init__(self, service, version, mode, path):
                        self.boiling_options = self.__class__.boiling_options(service, version, mode, path + ["boiling_options"])
                        self.boiling = self.__class__.boiling(service, version, mode, path + ["boiling"])
                        super().__init__(service, version, mode, path)
                    class boiling(TUIMethod):
                        """
                        Activate boiling model.
                        """

                    class boiling_options(TUIMenu):
                        """
                        Set boiling options.
                        """
                        def __init__(self, service, version, mode, path):
                            self.nlbf_model = self.__class__.nlbf_model(service, version, mode, path + ["nlbf_model"])
                            self.options = self.__class__.options(service, version, mode, path + ["options"])
                            super().__init__(service, version, mode, path)
                        class nlbf_model(TUIMethod):
                            """
                            Set the non-local boundary field correction.
                            """
                        class options(TUIMethod):
                            """
                            Choose the type of boiling model.
                            """

                class volume_fraction_parameters(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.courant_number = self.__class__.courant_number(service, version, mode, path + ["courant_number"])
                        self.formulation = self.__class__.formulation(service, version, mode, path + ["formulation"])
                        self.volume_fraction_cutoff = self.__class__.volume_fraction_cutoff(service, version, mode, path + ["volume_fraction_cutoff"])
                        super().__init__(service, version, mode, path)
                    class courant_number(TUIMethod):
                        """
                        .
                        """
                    class formulation(TUIMethod):
                        """
                        .
                        """
                    class volume_fraction_cutoff(TUIMethod):
                        """
                        .
                        """

                class wet_steam(TUIMenu):
                    """
                    Enter the wet steam model menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.set = self.__class__.set(service, version, mode, path + ["set"])
                        self.compile_user_defined_wetsteam_functions = self.__class__.compile_user_defined_wetsteam_functions(service, version, mode, path + ["compile_user_defined_wetsteam_functions"])
                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                        self.load_unload_user_defined_wetsteam_library = self.__class__.load_unload_user_defined_wetsteam_library(service, version, mode, path + ["load_unload_user_defined_wetsteam_library"])
                        super().__init__(service, version, mode, path)
                    class compile_user_defined_wetsteam_functions(TUIMethod):
                        """
                        Compile user-defined wet steam library.
                        """
                    class enable(TUIMethod):
                        """
                        .
                        """
                    class load_unload_user_defined_wetsteam_library(TUIMethod):
                        """
                        Load or unload user-defined wet steam library.
                        """

                    class set(TUIMenu):
                        """
                        Enter the set menu for setting wet steam model options.
                        """
                        def __init__(self, service, version, mode, path):
                            self.droplet_growth_rate = self.__class__.droplet_growth_rate(service, version, mode, path + ["droplet_growth_rate"])
                            self.enhanced_source_linearization = self.__class__.enhanced_source_linearization(service, version, mode, path + ["enhanced_source_linearization"])
                            self.max_liquid_mass_fraction = self.__class__.max_liquid_mass_fraction(service, version, mode, path + ["max_liquid_mass_fraction"])
                            self.rgp_tables = self.__class__.rgp_tables(service, version, mode, path + ["rgp_tables"])
                            self.stagnation_conditions = self.__class__.stagnation_conditions(service, version, mode, path + ["stagnation_conditions"])
                            self.virial_equation = self.__class__.virial_equation(service, version, mode, path + ["virial_equation"])
                            self.zonal_phase_change = self.__class__.zonal_phase_change(service, version, mode, path + ["zonal_phase_change"])
                            super().__init__(service, version, mode, path)
                        class droplet_growth_rate(TUIMethod):
                            """
                            .
                            """
                        class enhanced_source_linearization(TUIMethod):
                            """
                            .
                            """
                        class max_liquid_mass_fraction(TUIMethod):
                            """
                            .
                            """
                        class rgp_tables(TUIMethod):
                            """
                            Select which properties to use: build-in or from RGP tables.
                            """
                        class stagnation_conditions(TUIMethod):
                            """
                            .
                            """
                        class virial_equation(TUIMethod):
                            """
                            .
                            """
                        class zonal_phase_change(TUIMethod):
                            """
                            Select cell zones where phase change process is active.
                            """

            class nox_parameters(TUIMenu):
                """
                Enter the NOx parameters menu.
                """
                def __init__(self, service, version, mode, path):
                    self.inlet_diffusion = self.__class__.inlet_diffusion(service, version, mode, path + ["inlet_diffusion"])
                    self.nox_chemistry = self.__class__.nox_chemistry(service, version, mode, path + ["nox_chemistry"])
                    self.nox_expert = self.__class__.nox_expert(service, version, mode, path + ["nox_expert"])
                    self.nox_turbulence_interaction = self.__class__.nox_turbulence_interaction(service, version, mode, path + ["nox_turbulence_interaction"])
                    super().__init__(service, version, mode, path)
                class inlet_diffusion(TUIMethod):
                    """
                    Enable/disable inclusion of diffusion at inlets.
                    """
                class nox_chemistry(TUIMethod):
                    """
                    Select NOx chemistry model.
                    """
                class nox_expert(TUIMethod):
                    """
                    Select additional nox equations.
                    """
                class nox_turbulence_interaction(TUIMethod):
                    """
                    Set NOx-turbulence interaction model.
                    """

            class optics(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.beams = self.__class__.beams(service, version, mode, path + ["beams"])
                    self.statistics = self.__class__.statistics(service, version, mode, path + ["statistics"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.index_of_refraction = self.__class__.index_of_refraction(service, version, mode, path + ["index_of_refraction"])
                    self.report = self.__class__.report(service, version, mode, path + ["report"])
                    self.sampling_iterations = self.__class__.sampling_iterations(service, version, mode, path + ["sampling_iterations"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    .
                    """
                class index_of_refraction(TUIMethod):
                    """
                    .
                    """
                class report(TUIMethod):
                    """
                    .
                    """
                class sampling_iterations(TUIMethod):
                    """
                    .
                    """
                class verbosity(TUIMethod):
                    """
                    .
                    """

                class beams(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.add = self.__class__.add(service, version, mode, path + ["add"])
                        self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class add(TUIMethod):
                        """
                        Create a new beams object.
                        """
                    class copy(TUIMethod):
                        """
                        .
                        """
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit beams object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

                class statistics(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.reset_statistics = self.__class__.reset_statistics(service, version, mode, path + ["reset_statistics"])
                        self.statistics_controls = self.__class__.statistics_controls(service, version, mode, path + ["statistics_controls"])
                        super().__init__(service, version, mode, path)
                    class reset_statistics(TUIMethod):
                        """
                        .
                        """
                    class statistics_controls(TUIMethod):
                        """
                        .
                        """

            class radiation(TUIMenu):
                """
                Enter the radiation models menu.
                """
                def __init__(self, service, version, mode, path):
                    self.dtrm_parameters = self.__class__.dtrm_parameters(service, version, mode, path + ["dtrm_parameters"])
                    self.s2s_parameters = self.__class__.s2s_parameters(service, version, mode, path + ["s2s_parameters"])
                    self.solar_parameters = self.__class__.solar_parameters(service, version, mode, path + ["solar_parameters"])
                    self.apply_full_solar_irradiation = self.__class__.apply_full_solar_irradiation(service, version, mode, path + ["apply_full_solar_irradiation"])
                    self.beta_radiation_features = self.__class__.beta_radiation_features(service, version, mode, path + ["beta_radiation_features"])
                    self.blending_factor = self.__class__.blending_factor(service, version, mode, path + ["blending_factor"])
                    self.discrete_ordinates = self.__class__.discrete_ordinates(service, version, mode, path + ["discrete_ordinates"])
                    self.discrete_transfer = self.__class__.discrete_transfer(service, version, mode, path + ["discrete_transfer"])
                    self.do_acceleration = self.__class__.do_acceleration(service, version, mode, path + ["do_acceleration"])
                    self.do_coupling = self.__class__.do_coupling(service, version, mode, path + ["do_coupling"])
                    self.fast_second_order_discrete_ordinate = self.__class__.fast_second_order_discrete_ordinate(service, version, mode, path + ["fast_second_order_discrete_ordinate"])
                    self.mc_model_parameters = self.__class__.mc_model_parameters(service, version, mode, path + ["mc_model_parameters"])
                    self.mc_under_relaxation = self.__class__.mc_under_relaxation(service, version, mode, path + ["mc_under_relaxation"])
                    self.method_partially_specular_wall = self.__class__.method_partially_specular_wall(service, version, mode, path + ["method_partially_specular_wall"])
                    self.montecarlo = self.__class__.montecarlo(service, version, mode, path + ["montecarlo"])
                    self.non_gray_model_parameters = self.__class__.non_gray_model_parameters(service, version, mode, path + ["non_gray_model_parameters"])
                    self.p1 = self.__class__.p1(service, version, mode, path + ["p1"])
                    self.radiation_iteration_parameters = self.__class__.radiation_iteration_parameters(service, version, mode, path + ["radiation_iteration_parameters"])
                    self.radiation_model_parameters = self.__class__.radiation_model_parameters(service, version, mode, path + ["radiation_model_parameters"])
                    self.rosseland = self.__class__.rosseland(service, version, mode, path + ["rosseland"])
                    self.s2s = self.__class__.s2s(service, version, mode, path + ["s2s"])
                    self.solar = self.__class__.solar(service, version, mode, path + ["solar"])
                    self.solar_calculator = self.__class__.solar_calculator(service, version, mode, path + ["solar_calculator"])
                    self.solar_irradiation = self.__class__.solar_irradiation(service, version, mode, path + ["solar_irradiation"])
                    self.solution_method_for_do_coupling = self.__class__.solution_method_for_do_coupling(service, version, mode, path + ["solution_method_for_do_coupling"])
                    self.target_cells_per_volume_cluster = self.__class__.target_cells_per_volume_cluster(service, version, mode, path + ["target_cells_per_volume_cluster"])
                    self.wsggm_cell_based = self.__class__.wsggm_cell_based(service, version, mode, path + ["wsggm_cell_based"])
                    super().__init__(service, version, mode, path)
                class apply_full_solar_irradiation(TUIMethod):
                    """
                    .
                    """
                class beta_radiation_features(TUIMethod):
                    """
                    Enable Radiation Models with Non-Iterative Time Advancement (NITA) as Beta features in FL12.0.
                    """
                class blending_factor(TUIMethod):
                    """
                    .
                    """
                class discrete_ordinates(TUIMethod):
                    """
                    Enable/disable the discrete ordinates radiation model.
                    """
                class discrete_transfer(TUIMethod):
                    """
                    Enable/disable discrete the transfer radiation model.
                    """
                class do_acceleration(TUIMethod):
                    """
                    .
                    """
                class do_coupling(TUIMethod):
                    """
                    .
                    """
                class fast_second_order_discrete_ordinate(TUIMethod):
                    """
                    .
                    """
                class mc_model_parameters(TUIMethod):
                    """
                    Set parameters for montecarlo radiation model.
                    """
                class mc_under_relaxation(TUIMethod):
                    """
                    .
                    """
                class method_partially_specular_wall(TUIMethod):
                    """
                    .
                    """
                class montecarlo(TUIMethod):
                    """
                    Enable/disable the Monte Carlo radiation model.
                    """
                class non_gray_model_parameters(TUIMethod):
                    """
                    Set parameters for non-gray model.
                    """
                class p1(TUIMethod):
                    """
                    Enable/disable the P1 radiation model.
                    """
                class radiation_iteration_parameters(TUIMethod):
                    """
                    Set iteration parameters for radiation models.
                    """
                class radiation_model_parameters(TUIMethod):
                    """
                    Set parameters for radiation models.
                    """
                class rosseland(TUIMethod):
                    """
                    Enable/disable the Rosseland radiation model.
                    """
                class s2s(TUIMethod):
                    """
                    Enable/disable the S2S radiation model.
                    """
                class solar(TUIMethod):
                    """
                    Enable/Disable solar load model.
                    """
                class solar_calculator(TUIMethod):
                    """
                    .
                    """
                class solar_irradiation(TUIMethod):
                    """
                    Enable/disable the Solar irradiation model.
                    """
                class solution_method_for_do_coupling(TUIMethod):
                    """
                    .
                    """
                class target_cells_per_volume_cluster(TUIMethod):
                    """
                    .
                    """
                class wsggm_cell_based(TUIMethod):
                    """
                    Enable/disable WSGGM cell based method.
                    """

                class dtrm_parameters(TUIMenu):
                    """
                    Enter the DTRM parameters menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.check_ray_file = self.__class__.check_ray_file(service, version, mode, path + ["check_ray_file"])
                        self.controls = self.__class__.controls(service, version, mode, path + ["controls"])
                        self.make_globs = self.__class__.make_globs(service, version, mode, path + ["make_globs"])
                        self.ray_trace = self.__class__.ray_trace(service, version, mode, path + ["ray_trace"])
                        super().__init__(service, version, mode, path)
                    class check_ray_file(TUIMethod):
                        """
                        Read DTRM rays file.
                        """
                    class controls(TUIMethod):
                        """
                        Set DTRM solution controls.
                        """
                    class make_globs(TUIMethod):
                        """
                        Make globs (coarser mesh) for radiation.
                        """
                    class ray_trace(TUIMethod):
                        """
                        Create DTRM rays for radiation.
                        """

                class s2s_parameters(TUIMenu):
                    """
                    Enter the S2S parameters menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.compute_fpsc_values = self.__class__.compute_fpsc_values(service, version, mode, path + ["compute_fpsc_values"])
                        self.compute_vf_accelerated = self.__class__.compute_vf_accelerated(service, version, mode, path + ["compute_vf_accelerated"])
                        self.compute_vf_only = self.__class__.compute_vf_only(service, version, mode, path + ["compute_vf_only"])
                        self.compute_write_vf = self.__class__.compute_write_vf(service, version, mode, path + ["compute_write_vf"])
                        self.enable_mesh_interface_clustering = self.__class__.enable_mesh_interface_clustering(service, version, mode, path + ["enable_mesh_interface_clustering"])
                        self.non_participating_boundary_zones_temperature = self.__class__.non_participating_boundary_zones_temperature(service, version, mode, path + ["non_participating_boundary_zones_temperature"])
                        self.print_thread_clusters = self.__class__.print_thread_clusters(service, version, mode, path + ["print_thread_clusters"])
                        self.print_zonewise_radiation = self.__class__.print_zonewise_radiation(service, version, mode, path + ["print_zonewise_radiation"])
                        self.read_vf_file = self.__class__.read_vf_file(service, version, mode, path + ["read_vf_file"])
                        self.set_global_faces_per_surface_cluster = self.__class__.set_global_faces_per_surface_cluster(service, version, mode, path + ["set_global_faces_per_surface_cluster"])
                        self.set_vf_parameters = self.__class__.set_vf_parameters(service, version, mode, path + ["set_vf_parameters"])
                        self.split_angle = self.__class__.split_angle(service, version, mode, path + ["split_angle"])
                        self.use_new_cluster_algorithm = self.__class__.use_new_cluster_algorithm(service, version, mode, path + ["use_new_cluster_algorithm"])
                        self.use_old_cluster_algorithm = self.__class__.use_old_cluster_algorithm(service, version, mode, path + ["use_old_cluster_algorithm"])
                        super().__init__(service, version, mode, path)
                    class compute_fpsc_values(TUIMethod):
                        """
                        Compute only fpsc values based on current settings.
                        """
                    class compute_vf_accelerated(TUIMethod):
                        """
                        .
                        """
                    class compute_vf_only(TUIMethod):
                        """
                        .
                        """
                    class compute_write_vf(TUIMethod):
                        """
                        .
                        """
                    class enable_mesh_interface_clustering(TUIMethod):
                        """
                        .
                        """
                    class non_participating_boundary_zones_temperature(TUIMethod):
                        """
                        .
                        """
                    class print_thread_clusters(TUIMethod):
                        """
                        .
                        """
                    class print_zonewise_radiation(TUIMethod):
                        """
                        Prints the zonewise incoming radiation, viewfactors, and average temperature.
                        """
                    class read_vf_file(TUIMethod):
                        """
                        .
                        """
                    class set_global_faces_per_surface_cluster(TUIMethod):
                        """
                        Set global value of faces per surface cluster for all boundary zones.
                        """
                    class set_vf_parameters(TUIMethod):
                        """
                        Set the parameters needed for the view factor calculations.
                        """
                    class split_angle(TUIMethod):
                        """
                        .
                        """
                    class use_new_cluster_algorithm(TUIMethod):
                        """
                        Use the new surface clustering algorithm.
                        """
                    class use_old_cluster_algorithm(TUIMethod):
                        """
                        Use the old surface clustering algorithm.
                        """

                class solar_parameters(TUIMenu):
                    """
                    Enter the solar parameters menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.ground_reflectivity = self.__class__.ground_reflectivity(service, version, mode, path + ["ground_reflectivity"])
                        self.illumination_parameters = self.__class__.illumination_parameters(service, version, mode, path + ["illumination_parameters"])
                        self.iteration_parameters = self.__class__.iteration_parameters(service, version, mode, path + ["iteration_parameters"])
                        self.quad_tree_parameters = self.__class__.quad_tree_parameters(service, version, mode, path + ["quad_tree_parameters"])
                        self.scattering_fraction = self.__class__.scattering_fraction(service, version, mode, path + ["scattering_fraction"])
                        self.sol_adjacent_fluidcells = self.__class__.sol_adjacent_fluidcells(service, version, mode, path + ["sol_adjacent_fluidcells"])
                        self.sol_camera_pos = self.__class__.sol_camera_pos(service, version, mode, path + ["sol_camera_pos"])
                        self.sol_on_demand = self.__class__.sol_on_demand(service, version, mode, path + ["sol_on_demand"])
                        self.solar_thread_control = self.__class__.solar_thread_control(service, version, mode, path + ["solar_thread_control"])
                        self.sun_direction_vector = self.__class__.sun_direction_vector(service, version, mode, path + ["sun_direction_vector"])
                        self.use_direction_from_sol_calc = self.__class__.use_direction_from_sol_calc(service, version, mode, path + ["use_direction_from_sol_calc"])
                        super().__init__(service, version, mode, path)
                    class ground_reflectivity(TUIMethod):
                        """
                        .
                        """
                    class illumination_parameters(TUIMethod):
                        """
                        Set illumination parameters.
                        """
                    class iteration_parameters(TUIMethod):
                        """
                        .
                        """
                    class quad_tree_parameters(TUIMethod):
                        """
                        .
                        """
                    class scattering_fraction(TUIMethod):
                        """
                        .
                        """
                    class sol_adjacent_fluidcells(TUIMethod):
                        """
                        .
                        """
                    class sol_camera_pos(TUIMethod):
                        """
                        Set camera position based on sun direction vector.
                        """
                    class sol_on_demand(TUIMethod):
                        """
                        .
                        """
                    class solar_thread_control(TUIMethod):
                        """
                        Solar thread control.
                        """
                    class sun_direction_vector(TUIMethod):
                        """
                        .
                        """
                    class use_direction_from_sol_calc(TUIMethod):
                        """
                        .
                        """

            class shell_conduction(TUIMenu):
                """
                Enter the shell conduction model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.enhanced_encapsulation = self.__class__.enhanced_encapsulation(service, version, mode, path + ["enhanced_encapsulation"])
                    self.multi_layer_shell = self.__class__.multi_layer_shell(service, version, mode, path + ["multi_layer_shell"])
                    self.read_csv = self.__class__.read_csv(service, version, mode, path + ["read_csv"])
                    self.save_shell_zones = self.__class__.save_shell_zones(service, version, mode, path + ["save_shell_zones"])
                    self.settings = self.__class__.settings(service, version, mode, path + ["settings"])
                    self.write_csv = self.__class__.write_csv(service, version, mode, path + ["write_csv"])
                    super().__init__(service, version, mode, path)
                class enhanced_encapsulation(TUIMethod):
                    """
                    Enable/disable enhanced encapsulation for shell conduction and S2S models. This is not applicable if coupled sliding interface walls exists.
                    """
                class multi_layer_shell(TUIMethod):
                    """
                    Enable/disable multi layer shell conduction model.
                    """
                class read_csv(TUIMethod):
                    """
                    Read shell conduction settings from a csv file.
                    """
                class save_shell_zones(TUIMethod):
                    """
                    Enable/Disable saving shell zones to case file.
                    """
                class settings(TUIMethod):
                    """
                    Enter Multi-layer Shell Conduction data.
                    """
                class write_csv(TUIMethod):
                    """
                    Write shell conduction settings to a csv file.
                    """

            class solver(TUIMenu):
                """
                Enter the menu to select the solver.
                """
                def __init__(self, service, version, mode, path):
                    self.adjust_solver_defaults_based_on_setup = self.__class__.adjust_solver_defaults_based_on_setup(service, version, mode, path + ["adjust_solver_defaults_based_on_setup"])
                    self.density_based_explicit = self.__class__.density_based_explicit(service, version, mode, path + ["density_based_explicit"])
                    self.density_based_implicit = self.__class__.density_based_implicit(service, version, mode, path + ["density_based_implicit"])
                    self.pressure_based = self.__class__.pressure_based(service, version, mode, path + ["pressure_based"])
                    super().__init__(service, version, mode, path)
                class adjust_solver_defaults_based_on_setup(TUIMethod):
                    """
                    .
                    """
                class density_based_explicit(TUIMethod):
                    """
                    Enable/disable the coupled-explicit solver.
                    """
                class density_based_implicit(TUIMethod):
                    """
                    Enable/disable the coupled-implicit solver.
                    """
                class pressure_based(TUIMethod):
                    """
                    Enable/disable the segregated solver.
                    """

            class soot_parameters(TUIMenu):
                """
                Enter the soot parameters menu.
                """
                def __init__(self, service, version, mode, path):
                    self.inlet_diffusion = self.__class__.inlet_diffusion(service, version, mode, path + ["inlet_diffusion"])
                    self.modify_schmidt_number = self.__class__.modify_schmidt_number(service, version, mode, path + ["modify_schmidt_number"])
                    self.soot_model_parameters = self.__class__.soot_model_parameters(service, version, mode, path + ["soot_model_parameters"])
                    self.soot_model_udfs = self.__class__.soot_model_udfs(service, version, mode, path + ["soot_model_udfs"])
                    self.soot_process_parameters = self.__class__.soot_process_parameters(service, version, mode, path + ["soot_process_parameters"])
                    self.soot_radiation_interaction = self.__class__.soot_radiation_interaction(service, version, mode, path + ["soot_radiation_interaction"])
                    self.soot_turbulence_interaction = self.__class__.soot_turbulence_interaction(service, version, mode, path + ["soot_turbulence_interaction"])
                    super().__init__(service, version, mode, path)
                class inlet_diffusion(TUIMethod):
                    """
                    Enable/disable inclusion of diffusion at inlets.
                    """
                class modify_schmidt_number(TUIMethod):
                    """
                    Change Turbulent Schmidt Number for Soot/Nuclei Equations.
                    """
                class soot_model_parameters(TUIMethod):
                    """
                    Enter the soot model parameters menu.
                    """
                class soot_model_udfs(TUIMethod):
                    """
                    User defined functions for soot model.
                    """
                class soot_process_parameters(TUIMethod):
                    """
                    Set soot process parameters.
                    """
                class soot_radiation_interaction(TUIMethod):
                    """
                    Enable/disable the soot-radiation interaction model.
                    """
                class soot_turbulence_interaction(TUIMethod):
                    """
                    Set Soot-turbulence interaction model.
                    """

            class species(TUIMenu):
                """
                Enter the species models menu.
                """
                def __init__(self, service, version, mode, path):
                    self.CHEMKIN_CFD_parameters = self.__class__.CHEMKIN_CFD_parameters(service, version, mode, path + ["CHEMKIN_CFD_parameters"])
                    self.CHEMKIN_CFD = self.__class__.CHEMKIN_CFD(service, version, mode, path + ["CHEMKIN_CFD"])
                    self.clear_isat_table = self.__class__.clear_isat_table(service, version, mode, path + ["clear_isat_table"])
                    self.coal_calculator = self.__class__.coal_calculator(service, version, mode, path + ["coal_calculator"])
                    self.combustion_expert = self.__class__.combustion_expert(service, version, mode, path + ["combustion_expert"])
                    self.combustion_numerics = self.__class__.combustion_numerics(service, version, mode, path + ["combustion_numerics"])
                    self.decoupled_detailed_chemistry = self.__class__.decoupled_detailed_chemistry(service, version, mode, path + ["decoupled_detailed_chemistry"])
                    self.diffusion_energy_source = self.__class__.diffusion_energy_source(service, version, mode, path + ["diffusion_energy_source"])
                    self.electro_chemical_surface_reactions = self.__class__.electro_chemical_surface_reactions(service, version, mode, path + ["electro_chemical_surface_reactions"])
                    self.epdf_energy = self.__class__.epdf_energy(service, version, mode, path + ["epdf_energy"])
                    self.flamelet_expert = self.__class__.flamelet_expert(service, version, mode, path + ["flamelet_expert"])
                    self.full_tabulation = self.__class__.full_tabulation(service, version, mode, path + ["full_tabulation"])
                    self.heat_of_surface_reactions = self.__class__.heat_of_surface_reactions(service, version, mode, path + ["heat_of_surface_reactions"])
                    self.ignition_model = self.__class__.ignition_model(service, version, mode, path + ["ignition_model"])
                    self.ignition_model_controls = self.__class__.ignition_model_controls(service, version, mode, path + ["ignition_model_controls"])
                    self.import_flamelet_for_restart = self.__class__.import_flamelet_for_restart(service, version, mode, path + ["import_flamelet_for_restart"])
                    self.inert_transport_controls = self.__class__.inert_transport_controls(service, version, mode, path + ["inert_transport_controls"])
                    self.inert_transport_model = self.__class__.inert_transport_model(service, version, mode, path + ["inert_transport_model"])
                    self.init_unsteady_flamelet_prob = self.__class__.init_unsteady_flamelet_prob(service, version, mode, path + ["init_unsteady_flamelet_prob"])
                    self.inlet_diffusion = self.__class__.inlet_diffusion(service, version, mode, path + ["inlet_diffusion"])
                    self.integration_parameters = self.__class__.integration_parameters(service, version, mode, path + ["integration_parameters"])
                    self.liquid_energy_diffusion = self.__class__.liquid_energy_diffusion(service, version, mode, path + ["liquid_energy_diffusion"])
                    self.liquid_micro_mixing = self.__class__.liquid_micro_mixing(service, version, mode, path + ["liquid_micro_mixing"])
                    self.mass_deposition_source = self.__class__.mass_deposition_source(service, version, mode, path + ["mass_deposition_source"])
                    self.mixing_model = self.__class__.mixing_model(service, version, mode, path + ["mixing_model"])
                    self.multicomponent_diffusion = self.__class__.multicomponent_diffusion(service, version, mode, path + ["multicomponent_diffusion"])
                    self.non_premixed_combustion = self.__class__.non_premixed_combustion(service, version, mode, path + ["non_premixed_combustion"])
                    self.non_premixed_combustion_expert = self.__class__.non_premixed_combustion_expert(service, version, mode, path + ["non_premixed_combustion_expert"])
                    self.non_premixed_combustion_parameters = self.__class__.non_premixed_combustion_parameters(service, version, mode, path + ["non_premixed_combustion_parameters"])
                    self.off = self.__class__.off(service, version, mode, path + ["off"])
                    self.partially_premixed_combustion = self.__class__.partially_premixed_combustion(service, version, mode, path + ["partially_premixed_combustion"])
                    self.partially_premixed_combustion_expert = self.__class__.partially_premixed_combustion_expert(service, version, mode, path + ["partially_premixed_combustion_expert"])
                    self.partially_premixed_combustion_grids = self.__class__.partially_premixed_combustion_grids(service, version, mode, path + ["partially_premixed_combustion_grids"])
                    self.partially_premixed_combustion_parameters = self.__class__.partially_premixed_combustion_parameters(service, version, mode, path + ["partially_premixed_combustion_parameters"])
                    self.partially_premixed_properties = self.__class__.partially_premixed_properties(service, version, mode, path + ["partially_premixed_properties"])
                    self.particle_reactions = self.__class__.particle_reactions(service, version, mode, path + ["particle_reactions"])
                    self.pdf_transport = self.__class__.pdf_transport(service, version, mode, path + ["pdf_transport"])
                    self.pdf_transport_expert = self.__class__.pdf_transport_expert(service, version, mode, path + ["pdf_transport_expert"])
                    self.premixed_combustion = self.__class__.premixed_combustion(service, version, mode, path + ["premixed_combustion"])
                    self.premixed_model = self.__class__.premixed_model(service, version, mode, path + ["premixed_model"])
                    self.re_calc_par_premix_props = self.__class__.re_calc_par_premix_props(service, version, mode, path + ["re_calc_par_premix_props"])
                    self.reacting_channel_model = self.__class__.reacting_channel_model(service, version, mode, path + ["reacting_channel_model"])
                    self.reacting_channel_model_options = self.__class__.reacting_channel_model_options(service, version, mode, path + ["reacting_channel_model_options"])
                    self.reaction_diffusion_balance = self.__class__.reaction_diffusion_balance(service, version, mode, path + ["reaction_diffusion_balance"])
                    self.reactor_network_model = self.__class__.reactor_network_model(service, version, mode, path + ["reactor_network_model"])
                    self.relax_to_equil = self.__class__.relax_to_equil(service, version, mode, path + ["relax_to_equil"])
                    self.save_gradients = self.__class__.save_gradients(service, version, mode, path + ["save_gradients"])
                    self.set_multi_regime_fgm = self.__class__.set_multi_regime_fgm(service, version, mode, path + ["set_multi_regime_fgm"])
                    self.set_premixed_combustion = self.__class__.set_premixed_combustion(service, version, mode, path + ["set_premixed_combustion"])
                    self.set_turb_chem_interaction = self.__class__.set_turb_chem_interaction(service, version, mode, path + ["set_turb_chem_interaction"])
                    self.spark_model = self.__class__.spark_model(service, version, mode, path + ["spark_model"])
                    self.species_migration = self.__class__.species_migration(service, version, mode, path + ["species_migration"])
                    self.species_transport = self.__class__.species_transport(service, version, mode, path + ["species_transport"])
                    self.species_transport_expert = self.__class__.species_transport_expert(service, version, mode, path + ["species_transport_expert"])
                    self.stiff_chemistry = self.__class__.stiff_chemistry(service, version, mode, path + ["stiff_chemistry"])
                    self.surf_reaction_aggressiveness_factor = self.__class__.surf_reaction_aggressiveness_factor(service, version, mode, path + ["surf_reaction_aggressiveness_factor"])
                    self.surf_reaction_netm_params = self.__class__.surf_reaction_netm_params(service, version, mode, path + ["surf_reaction_netm_params"])
                    self.thermal_diffusion = self.__class__.thermal_diffusion(service, version, mode, path + ["thermal_diffusion"])
                    self.thickened_flame_model = self.__class__.thickened_flame_model(service, version, mode, path + ["thickened_flame_model"])
                    self.volumetric_reactions = self.__class__.volumetric_reactions(service, version, mode, path + ["volumetric_reactions"])
                    self.wall_surface_reactions = self.__class__.wall_surface_reactions(service, version, mode, path + ["wall_surface_reactions"])
                    self.water_corrosion_pre = self.__class__.water_corrosion_pre(service, version, mode, path + ["water_corrosion_pre"])
                    super().__init__(service, version, mode, path)
                class CHEMKIN_CFD(TUIMethod):
                    """
                    Enable/disable CHEMKIN-CFD.
                    """
                class clear_isat_table(TUIMethod):
                    """
                    Clear the ISAT table.
                    """
                class coal_calculator(TUIMethod):
                    """
                    Set up coal modeling inputs.
                    """
                class combustion_expert(TUIMethod):
                    """
                    Set combustion expert parameters.
                    """
                class combustion_numerics(TUIMethod):
                    """
                    Set combustion numerics options.
                    """
                class decoupled_detailed_chemistry(TUIMethod):
                    """
                    Enable/disable the Decoupled Detailed Chemistry model.
                    """
                class diffusion_energy_source(TUIMethod):
                    """
                    .
                    """
                class electro_chemical_surface_reactions(TUIMethod):
                    """
                    .
                    """
                class epdf_energy(TUIMethod):
                    """
                    Enable/disable EPDF energy  option.
                    """
                class flamelet_expert(TUIMethod):
                    """
                    Set flamelet expert parameters.
                    """
                class full_tabulation(TUIMethod):
                    """
                    Enable/disable building of a full 2 mixture fraction table.
                    """
                class heat_of_surface_reactions(TUIMethod):
                    """
                    .
                    """
                class ignition_model(TUIMethod):
                    """
                    Enable/disable the ignition model.
                    """
                class ignition_model_controls(TUIMethod):
                    """
                    Set ignition model parameters.
                    """
                class import_flamelet_for_restart(TUIMethod):
                    """
                    Import Flamelet File for Restart.
                    """
                class inert_transport_controls(TUIMethod):
                    """
                    Set inert transport model parameters.
                    """
                class inert_transport_model(TUIMethod):
                    """
                    Enable/disable the inert transport model.
                    """
                class init_unsteady_flamelet_prob(TUIMethod):
                    """
                    Initialize Unsteady Flamelet Probability.
                    """
                class inlet_diffusion(TUIMethod):
                    """
                    Enable/disable inclusion of diffusion at inlets.
                    """
                class integration_parameters(TUIMethod):
                    """
                    Set ISAT parameters.
                    """
                class liquid_energy_diffusion(TUIMethod):
                    """
                    .
                    """
                class liquid_micro_mixing(TUIMethod):
                    """
                    Enable/disable liquid micro mixing option.
                    """
                class mass_deposition_source(TUIMethod):
                    """
                    .
                    """
                class mixing_model(TUIMethod):
                    """
                    Set PDF transport mixing model.
                    """
                class multicomponent_diffusion(TUIMethod):
                    """
                    Enable/disable multicomponent diffusion.
                    """
                class non_premixed_combustion(TUIMethod):
                    """
                    Enable/disable the non-premixed combustion model.
                    """
                class non_premixed_combustion_expert(TUIMethod):
                    """
                    Set PDF expert parameters.
                    """
                class non_premixed_combustion_parameters(TUIMethod):
                    """
                    Set PDF parameters.
                    """
                class off(TUIMethod):
                    """
                    Enable/disable solution of species models.
                    """
                class partially_premixed_combustion(TUIMethod):
                    """
                    Enable/disable partially premixed combustion model.
                    """
                class partially_premixed_combustion_expert(TUIMethod):
                    """
                    Set PDF expert parameters.
                    """
                class partially_premixed_combustion_grids(TUIMethod):
                    """
                    Set user specified grid parameters for PDF and flamelet.
                    """
                class partially_premixed_combustion_parameters(TUIMethod):
                    """
                    Set PDF parameters.
                    """
                class partially_premixed_properties(TUIMethod):
                    """
                    Set/Change partially premixed mixture properties.
                    """
                class particle_reactions(TUIMethod):
                    """
                    .
                    """
                class pdf_transport(TUIMethod):
                    """
                    Enable/disable the composition PDF transport combustion model.
                    """
                class pdf_transport_expert(TUIMethod):
                    """
                    Enable/disable PDF transport expert user.
                    """
                class premixed_combustion(TUIMethod):
                    """
                    Enable/disable the premixed combustion model.
                    """
                class premixed_model(TUIMethod):
                    """
                    Set premixed combustion model.
                    """
                class re_calc_par_premix_props(TUIMethod):
                    """
                    Re-calculate partially-premixed properties.
                    """
                class reacting_channel_model(TUIMethod):
                    """
                    Enable/Disable the Reacting Channel Model.
                    """
                class reacting_channel_model_options(TUIMethod):
                    """
                    Set Reacting Channel Model parameters.
                    """
                class reaction_diffusion_balance(TUIMethod):
                    """
                    .
                    """
                class reactor_network_model(TUIMethod):
                    """
                    Enable/disable the Reactor Network model.
                    """
                class relax_to_equil(TUIMethod):
                    """
                    Enable/disable the Relaxation to Chemical Equilibrium model.
                    """
                class save_gradients(TUIMethod):
                    """
                    .
                    """
                class set_multi_regime_fgm(TUIMethod):
                    """
                    Set-multi-regim-fgm-parameters.
                    """
                class set_premixed_combustion(TUIMethod):
                    """
                    Set premixed combustion parameters.
                    """
                class set_turb_chem_interaction(TUIMethod):
                    """
                    Set Eddy-Dissipation Concept model constants.
                    """
                class spark_model(TUIMethod):
                    """
                    Set spark model parameters.
                    """
                class species_migration(TUIMethod):
                    """
                    .
                    """
                class species_transport(TUIMethod):
                    """
                    Enable/disable the species transport model.
                    """
                class species_transport_expert(TUIMethod):
                    """
                    Set species transport expert options.
                    """
                class stiff_chemistry(TUIMethod):
                    """
                    Enable/disable stiff chemistry option.
                    """
                class surf_reaction_aggressiveness_factor(TUIMethod):
                    """
                    .
                    """
                class surf_reaction_netm_params(TUIMethod):
                    """
                    Set the surface reaction parameters for the Non-Equilibrium Thermal Model.
                    """
                class thermal_diffusion(TUIMethod):
                    """
                    .
                    """
                class thickened_flame_model(TUIMethod):
                    """
                    Enable/disable the Thickened Flame Model.
                    """
                class volumetric_reactions(TUIMethod):
                    """
                    .
                    """
                class wall_surface_reactions(TUIMethod):
                    """
                    .
                    """
                class water_corrosion_pre(TUIMethod):
                    """
                    Compute water chemistry and set up corrosion material.
                    """

                class CHEMKIN_CFD_parameters(TUIMenu):
                    """
                    Enter the expert CHEMKIN-CFD parameters menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.add_cell_monitor = self.__class__.add_cell_monitor(service, version, mode, path + ["add_cell_monitor"])
                        self.advanced_options = self.__class__.advanced_options(service, version, mode, path + ["advanced_options"])
                        self.basic_options = self.__class__.basic_options(service, version, mode, path + ["basic_options"])
                        self.delete_cell_monitors = self.__class__.delete_cell_monitors(service, version, mode, path + ["delete_cell_monitors"])
                        self.list_cell_monitors = self.__class__.list_cell_monitors(service, version, mode, path + ["list_cell_monitors"])
                        super().__init__(service, version, mode, path)
                    class add_cell_monitor(TUIMethod):
                        """
                        Add a monitor cell for debug output.
                        """
                    class advanced_options(TUIMethod):
                        """
                        Set advanced parameter options.
                        """
                    class basic_options(TUIMethod):
                        """
                        Set basic parameter options.
                        """
                    class delete_cell_monitors(TUIMethod):
                        """
                        Delete cell monitors.
                        """
                    class list_cell_monitors(TUIMethod):
                        """
                        List cell monitors.
                        """

            class structure(TUIMenu):
                """
                Enter the structure model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.controls = self.__class__.controls(service, version, mode, path + ["controls"])
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.linear_elasticity = self.__class__.linear_elasticity(service, version, mode, path + ["linear_elasticity"])
                    self.nonlinear_elasticity = self.__class__.nonlinear_elasticity(service, version, mode, path + ["nonlinear_elasticity"])
                    self.structure_off = self.__class__.structure_off(service, version, mode, path + ["structure_off"])
                    self.thermal_effects = self.__class__.thermal_effects(service, version, mode, path + ["thermal_effects"])
                    super().__init__(service, version, mode, path)
                class linear_elasticity(TUIMethod):
                    """
                    Enable the linear elasticity model.
                    """
                class nonlinear_elasticity(TUIMethod):
                    """
                    Enable the nonlinear elasticity model.
                    """
                class structure_off(TUIMethod):
                    """
                    Disable the structural model.
                    """
                class thermal_effects(TUIMethod):
                    """
                    .
                    """

                class controls(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.amg_stabilization = self.__class__.amg_stabilization(service, version, mode, path + ["amg_stabilization"])
                        self.enhanced_strain = self.__class__.enhanced_strain(service, version, mode, path + ["enhanced_strain"])
                        self.max_iter = self.__class__.max_iter(service, version, mode, path + ["max_iter"])
                        self.numerical_damping_factor = self.__class__.numerical_damping_factor(service, version, mode, path + ["numerical_damping_factor"])
                        self.unsteady_damping_rayleigh = self.__class__.unsteady_damping_rayleigh(service, version, mode, path + ["unsteady_damping_rayleigh"])
                        super().__init__(service, version, mode, path)
                    class amg_stabilization(TUIMethod):
                        """
                        .
                        """
                    class enhanced_strain(TUIMethod):
                        """
                        .
                        """
                    class max_iter(TUIMethod):
                        """
                        .
                        """
                    class numerical_damping_factor(TUIMethod):
                        """
                        .
                        """
                    class unsteady_damping_rayleigh(TUIMethod):
                        """
                        .
                        """

                class expert(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.explicit_fsi_force = self.__class__.explicit_fsi_force(service, version, mode, path + ["explicit_fsi_force"])
                        self.include_pop_in_fsi_force = self.__class__.include_pop_in_fsi_force(service, version, mode, path + ["include_pop_in_fsi_force"])
                        self.include_viscous_fsi_force = self.__class__.include_viscous_fsi_force(service, version, mode, path + ["include_viscous_fsi_force"])
                        self.starting_t_re_initialization = self.__class__.starting_t_re_initialization(service, version, mode, path + ["starting_t_re_initialization"])
                        self.steady_2way_fsi = self.__class__.steady_2way_fsi(service, version, mode, path + ["steady_2way_fsi"])
                        super().__init__(service, version, mode, path)
                    class explicit_fsi_force(TUIMethod):
                        """
                        .
                        """
                    class include_pop_in_fsi_force(TUIMethod):
                        """
                        .
                        """
                    class include_viscous_fsi_force(TUIMethod):
                        """
                        .
                        """
                    class starting_t_re_initialization(TUIMethod):
                        """
                        .
                        """
                    class steady_2way_fsi(TUIMethod):
                        """
                        .
                        """

            class system_coupling_settings(TUIMenu):
                """
                Enter the system coupling model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.flow_boundary_coupling = self.__class__.flow_boundary_coupling(service, version, mode, path + ["flow_boundary_coupling"])
                    self.htc = self.__class__.htc(service, version, mode, path + ["htc"])
                    self.unsteady_statistics = self.__class__.unsteady_statistics(service, version, mode, path + ["unsteady_statistics"])
                    self.use_face_or_element_based_data_transfer = self.__class__.use_face_or_element_based_data_transfer(service, version, mode, path + ["use_face_or_element_based_data_transfer"])
                    self.user_defined_coupling_variables_via_udm = self.__class__.user_defined_coupling_variables_via_udm(service, version, mode, path + ["user_defined_coupling_variables_via_udm"])
                    super().__init__(service, version, mode, path)
                class use_face_or_element_based_data_transfer(TUIMethod):
                    """
                    Enable/disable face based data transfer.
                    """
                class user_defined_coupling_variables_via_udm(TUIMethod):
                    """
                    User defined coupling variables via UDM.
                    """

                class flow_boundary_coupling(TUIMenu):
                    """
                    Flow Boundary Coupling Menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.activate_flow_boundary_coupling_model = self.__class__.activate_flow_boundary_coupling_model(service, version, mode, path + ["activate_flow_boundary_coupling_model"])
                        self.specify_zones_to_activate = self.__class__.specify_zones_to_activate(service, version, mode, path + ["specify_zones_to_activate"])
                        self.specify_zones_to_deactivate = self.__class__.specify_zones_to_deactivate(service, version, mode, path + ["specify_zones_to_deactivate"])
                        super().__init__(service, version, mode, path)
                    class activate_flow_boundary_coupling_model(TUIMethod):
                        """
                        Activate/Deactivate Flow Boundary Coupling Model.
                        """
                    class specify_zones_to_activate(TUIMethod):
                        """
                        Activate Flow Boundary Coupling Zones.
                        """
                    class specify_zones_to_deactivate(TUIMethod):
                        """
                        Deactivate Flow Boundary Coupling Zones.
                        """

                class htc(TUIMenu):
                    """
                    Enter the heat transfer coeficient menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.htc_calculation_method = self.__class__.htc_calculation_method(service, version, mode, path + ["htc_calculation_method"])
                        super().__init__(service, version, mode, path)

                    class htc_calculation_method(TUIMenu):
                        """
                        Enter the htc calculation menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.use_tref_in_htc_calculation = self.__class__.use_tref_in_htc_calculation(service, version, mode, path + ["use_tref_in_htc_calculation"])
                            self.use_wall_function_based_htc = self.__class__.use_wall_function_based_htc(service, version, mode, path + ["use_wall_function_based_htc"])
                            self.use_yplus_based_htc_calculation = self.__class__.use_yplus_based_htc_calculation(service, version, mode, path + ["use_yplus_based_htc_calculation"])
                            super().__init__(service, version, mode, path)
                        class use_tref_in_htc_calculation(TUIMethod):
                            """
                            Enable/disable tref in htc computation.
                            """
                        class use_wall_function_based_htc(TUIMethod):
                            """
                            Enable/disable wall function based htc computation.
                            """
                        class use_yplus_based_htc_calculation(TUIMethod):
                            """
                            Enable/disable yplus in htc computation.
                            """

                class unsteady_statistics(TUIMenu):
                    """
                    Enter the unsteady statistics menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.sc_enable_sub_stepping_option_per_coupling_step = self.__class__.sc_enable_sub_stepping_option_per_coupling_step(service, version, mode, path + ["sc_enable_sub_stepping_option_per_coupling_step"])
                        super().__init__(service, version, mode, path)
                    class sc_enable_sub_stepping_option_per_coupling_step(TUIMethod):
                        """
                        Enable/disable sub stepping option per coupling step.
                        """

            class two_temperature(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.translational_vibrational_energy_relaxation = self.__class__.translational_vibrational_energy_relaxation(service, version, mode, path + ["translational_vibrational_energy_relaxation"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.nasa9_enhancement = self.__class__.nasa9_enhancement(service, version, mode, path + ["nasa9_enhancement"])
                    self.robustness_enhancement = self.__class__.robustness_enhancement(service, version, mode, path + ["robustness_enhancement"])
                    self.set_verbosity = self.__class__.set_verbosity(service, version, mode, path + ["set_verbosity"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    .
                    """
                class nasa9_enhancement(TUIMethod):
                    """
                    .
                    """
                class robustness_enhancement(TUIMethod):
                    """
                    .
                    """
                class set_verbosity(TUIMethod):
                    """
                    .
                    """

                class translational_vibrational_energy_relaxation(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                        self.model = self.__class__.model(service, version, mode, path + ["model"])
                        super().__init__(service, version, mode, path)
                    class model(TUIMethod):
                        """
                        .
                        """

                    class expert(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list_all = self.__class__.list_all(service, version, mode, path + ["list_all"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                            super().__init__(service, version, mode, path)
                        class edit(TUIMethod):
                            """
                            Edit expert object.
                            """
                        class list_all(TUIMethod):
                            """
                            .
                            """
                        class list_properties(TUIMethod):
                            """
                            .
                            """
                        class resize(TUIMethod):
                            """
                            .
                            """

            class virtual_blade_model(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.rotor = self.__class__.rotor(service, version, mode, path + ["rotor"])
                    self.apply = self.__class__.apply(service, version, mode, path + ["apply"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.mode = self.__class__.mode(service, version, mode, path + ["mode"])
                    super().__init__(service, version, mode, path)
                class apply(TUIMethod):
                    """
                    .
                    """
                class enable(TUIMethod):
                    """
                    .
                    """
                class mode(TUIMethod):
                    """
                    .
                    """

                class rotor(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.new = self.__class__.new(service, version, mode, path + ["new"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit rotor object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class new(TUIMethod):
                        """
                        Create a new rotor object.
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

            class viscous(TUIMenu):
                """
                Enter the viscous model menu.
                """
                def __init__(self, service, version, mode, path):
                    self.geko_options = self.__class__.geko_options(service, version, mode, path + ["geko_options"])
                    self.les_model_options = self.__class__.les_model_options(service, version, mode, path + ["les_model_options"])
                    self.multiphase_turbulence = self.__class__.multiphase_turbulence(service, version, mode, path + ["multiphase_turbulence"])
                    self.near_wall_treatment = self.__class__.near_wall_treatment(service, version, mode, path + ["near_wall_treatment"])
                    self.transition_model_options = self.__class__.transition_model_options(service, version, mode, path + ["transition_model_options"])
                    self.turbulence_expert = self.__class__.turbulence_expert(service, version, mode, path + ["turbulence_expert"])
                    self.add_intermittency_transition_model = self.__class__.add_intermittency_transition_model(service, version, mode, path + ["add_intermittency_transition_model"])
                    self.add_transition_model = self.__class__.add_transition_model(service, version, mode, path + ["add_transition_model"])
                    self.buoyancy_effects = self.__class__.buoyancy_effects(service, version, mode, path + ["buoyancy_effects"])
                    self.corner_flow_correction = self.__class__.corner_flow_correction(service, version, mode, path + ["corner_flow_correction"])
                    self.corner_flow_correction_ccorner = self.__class__.corner_flow_correction_ccorner(service, version, mode, path + ["corner_flow_correction_ccorner"])
                    self.curvature_correction = self.__class__.curvature_correction(service, version, mode, path + ["curvature_correction"])
                    self.curvature_correction_ccurv = self.__class__.curvature_correction_ccurv(service, version, mode, path + ["curvature_correction_ccurv"])
                    self.des_limiter_option = self.__class__.des_limiter_option(service, version, mode, path + ["des_limiter_option"])
                    self.detached_eddy_simulation = self.__class__.detached_eddy_simulation(service, version, mode, path + ["detached_eddy_simulation"])
                    self.geko = self.__class__.geko(service, version, mode, path + ["geko"])
                    self.inviscid = self.__class__.inviscid(service, version, mode, path + ["inviscid"])
                    self.k_kl_w = self.__class__.k_kl_w(service, version, mode, path + ["k_kl_w"])
                    self.ke1e = self.__class__.ke1e(service, version, mode, path + ["ke1e"])
                    self.ke_easm = self.__class__.ke_easm(service, version, mode, path + ["ke_easm"])
                    self.ke_realizable = self.__class__.ke_realizable(service, version, mode, path + ["ke_realizable"])
                    self.ke_rng = self.__class__.ke_rng(service, version, mode, path + ["ke_rng"])
                    self.ke_standard = self.__class__.ke_standard(service, version, mode, path + ["ke_standard"])
                    self.kw_bsl = self.__class__.kw_bsl(service, version, mode, path + ["kw_bsl"])
                    self.kw_buoyancy_effects = self.__class__.kw_buoyancy_effects(service, version, mode, path + ["kw_buoyancy_effects"])
                    self.kw_easm = self.__class__.kw_easm(service, version, mode, path + ["kw_easm"])
                    self.kw_geko = self.__class__.kw_geko(service, version, mode, path + ["kw_geko"])
                    self.kw_low_re_correction = self.__class__.kw_low_re_correction(service, version, mode, path + ["kw_low_re_correction"])
                    self.kw_shear_correction = self.__class__.kw_shear_correction(service, version, mode, path + ["kw_shear_correction"])
                    self.kw_sst = self.__class__.kw_sst(service, version, mode, path + ["kw_sst"])
                    self.kw_standard = self.__class__.kw_standard(service, version, mode, path + ["kw_standard"])
                    self.kw_wj_bsl_earsm = self.__class__.kw_wj_bsl_earsm(service, version, mode, path + ["kw_wj_bsl_earsm"])
                    self.laminar = self.__class__.laminar(service, version, mode, path + ["laminar"])
                    self.large_eddy_simulation = self.__class__.large_eddy_simulation(service, version, mode, path + ["large_eddy_simulation"])
                    self.les_dynamic_energy_flux = self.__class__.les_dynamic_energy_flux(service, version, mode, path + ["les_dynamic_energy_flux"])
                    self.les_dynamic_scalar_flux = self.__class__.les_dynamic_scalar_flux(service, version, mode, path + ["les_dynamic_scalar_flux"])
                    self.les_subgrid_dynamic_fvar = self.__class__.les_subgrid_dynamic_fvar(service, version, mode, path + ["les_subgrid_dynamic_fvar"])
                    self.les_subgrid_rng = self.__class__.les_subgrid_rng(service, version, mode, path + ["les_subgrid_rng"])
                    self.les_subgrid_sigma = self.__class__.les_subgrid_sigma(service, version, mode, path + ["les_subgrid_sigma"])
                    self.les_subgrid_smagorinsky = self.__class__.les_subgrid_smagorinsky(service, version, mode, path + ["les_subgrid_smagorinsky"])
                    self.les_subgrid_tke = self.__class__.les_subgrid_tke(service, version, mode, path + ["les_subgrid_tke"])
                    self.les_subgrid_vreman = self.__class__.les_subgrid_vreman(service, version, mode, path + ["les_subgrid_vreman"])
                    self.les_subgrid_wale = self.__class__.les_subgrid_wale(service, version, mode, path + ["les_subgrid_wale"])
                    self.les_subgrid_wmles = self.__class__.les_subgrid_wmles(service, version, mode, path + ["les_subgrid_wmles"])
                    self.les_subgrid_wmles_s_minus_omega = self.__class__.les_subgrid_wmles_s_minus_omega(service, version, mode, path + ["les_subgrid_wmles_s_minus_omega"])
                    self.low_pressure_boundary_slip = self.__class__.low_pressure_boundary_slip(service, version, mode, path + ["low_pressure_boundary_slip"])
                    self.mixing_length = self.__class__.mixing_length(service, version, mode, path + ["mixing_length"])
                    self.reynolds_stress_model = self.__class__.reynolds_stress_model(service, version, mode, path + ["reynolds_stress_model"])
                    self.rng_differential_visc = self.__class__.rng_differential_visc(service, version, mode, path + ["rng_differential_visc"])
                    self.rng_swirl_model = self.__class__.rng_swirl_model(service, version, mode, path + ["rng_swirl_model"])
                    self.rsm_bsl_based = self.__class__.rsm_bsl_based(service, version, mode, path + ["rsm_bsl_based"])
                    self.rsm_linear_pressure_strain = self.__class__.rsm_linear_pressure_strain(service, version, mode, path + ["rsm_linear_pressure_strain"])
                    self.rsm_omega_based = self.__class__.rsm_omega_based(service, version, mode, path + ["rsm_omega_based"])
                    self.rsm_or_earsm_geko_option = self.__class__.rsm_or_earsm_geko_option(service, version, mode, path + ["rsm_or_earsm_geko_option"])
                    self.rsm_solve_tke = self.__class__.rsm_solve_tke(service, version, mode, path + ["rsm_solve_tke"])
                    self.rsm_ssg_pressure_strain = self.__class__.rsm_ssg_pressure_strain(service, version, mode, path + ["rsm_ssg_pressure_strain"])
                    self.rsm_wall_echo = self.__class__.rsm_wall_echo(service, version, mode, path + ["rsm_wall_echo"])
                    self.sa_alternate_prod = self.__class__.sa_alternate_prod(service, version, mode, path + ["sa_alternate_prod"])
                    self.sa_damping = self.__class__.sa_damping(service, version, mode, path + ["sa_damping"])
                    self.sa_enhanced_wall_treatment = self.__class__.sa_enhanced_wall_treatment(service, version, mode, path + ["sa_enhanced_wall_treatment"])
                    self.sas = self.__class__.sas(service, version, mode, path + ["sas"])
                    self.spalart_allmaras = self.__class__.spalart_allmaras(service, version, mode, path + ["spalart_allmaras"])
                    self.trans_sst_roughness_correlation = self.__class__.trans_sst_roughness_correlation(service, version, mode, path + ["trans_sst_roughness_correlation"])
                    self.transition_sst = self.__class__.transition_sst(service, version, mode, path + ["transition_sst"])
                    self.turb_buoyancy_effects = self.__class__.turb_buoyancy_effects(service, version, mode, path + ["turb_buoyancy_effects"])
                    self.turb_compressibility = self.__class__.turb_compressibility(service, version, mode, path + ["turb_compressibility"])
                    self.user_defined = self.__class__.user_defined(service, version, mode, path + ["user_defined"])
                    self.user_defined_transition = self.__class__.user_defined_transition(service, version, mode, path + ["user_defined_transition"])
                    self.v2f = self.__class__.v2f(service, version, mode, path + ["v2f"])
                    self.zero_equation_hvac = self.__class__.zero_equation_hvac(service, version, mode, path + ["zero_equation_hvac"])
                    super().__init__(service, version, mode, path)
                class add_intermittency_transition_model(TUIMethod):
                    """
                    Enable/disable the intermittency transition model to account for transitional effects.
                    """
                class add_transition_model(TUIMethod):
                    """
                    .
                    """
                class buoyancy_effects(TUIMethod):
                    """
                    Enable/disable effects of buoyancy on turbulence.
                    """
                class corner_flow_correction(TUIMethod):
                    """
                    .
                    """
                class corner_flow_correction_ccorner(TUIMethod):
                    """
                    Set the corner flow correction coefficient CCORNER.
                    """
                class curvature_correction(TUIMethod):
                    """
                    .
                    """
                class curvature_correction_ccurv(TUIMethod):
                    """
                    Set the curvature correction coefficient CCURV.
                    """
                class des_limiter_option(TUIMethod):
                    """
                    .
                    """
                class detached_eddy_simulation(TUIMethod):
                    """
                    Enable/disable detached eddy simulation.
                    """
                class geko(TUIMethod):
                    """
                    Enable/disable the GEKO model.
                    """
                class inviscid(TUIMethod):
                    """
                    Enable/disable the inviscid flow model.
                    """
                class k_kl_w(TUIMethod):
                    """
                    Enable/disable the k-kl-omega turbulence model.
                    """
                class ke1e(TUIMethod):
                    """
                    Enable/disable the KE1E turbulence model.
                    """
                class ke_easm(TUIMethod):
                    """
                    Enable/disable the EASM k-epsilon turbulence model.
                    """
                class ke_realizable(TUIMethod):
                    """
                    Enable/disable the realizable k-epsilon turbulence model.
                    """
                class ke_rng(TUIMethod):
                    """
                    Enable/disable the RNG k-epsilon turbulence model.
                    """
                class ke_standard(TUIMethod):
                    """
                    Enable/disable the standard k-epsilon turbulence model.
                    """
                class kw_bsl(TUIMethod):
                    """
                    Enable/disable the BSL k-omega turbulence model.
                    """
                class kw_buoyancy_effects(TUIMethod):
                    """
                    Enable/disable effects of buoyancy on k-omega turbulence model.
                    """
                class kw_easm(TUIMethod):
                    """
                    Enable/disable the EASM k-omega turbulence model.
                    """
                class kw_geko(TUIMethod):
                    """
                    Enable/disable the GEKO turbulence model.
                    """
                class kw_low_re_correction(TUIMethod):
                    """
                    .
                    """
                class kw_shear_correction(TUIMethod):
                    """
                    .
                    """
                class kw_sst(TUIMethod):
                    """
                    Enable/disable the SST k-omega turbulence model.
                    """
                class kw_standard(TUIMethod):
                    """
                    Enable/disable the standard k-omega turbulence model.
                    """
                class kw_wj_bsl_earsm(TUIMethod):
                    """
                    Enable/disable the EASM k-omega turbulence model.
                    """
                class laminar(TUIMethod):
                    """
                    Enable/disable the laminar flow model.
                    """
                class large_eddy_simulation(TUIMethod):
                    """
                    Enable/disable large eddy simulation.
                    """
                class les_dynamic_energy_flux(TUIMethod):
                    """
                    .
                    """
                class les_dynamic_scalar_flux(TUIMethod):
                    """
                    .
                    """
                class les_subgrid_dynamic_fvar(TUIMethod):
                    """
                    .
                    """
                class les_subgrid_rng(TUIMethod):
                    """
                    Enable/disable the RNG subgrid-scale model.
                    """
                class les_subgrid_sigma(TUIMethod):
                    """
                    Enable/disable the Sigma subgrid-scale model.
                    """
                class les_subgrid_smagorinsky(TUIMethod):
                    """
                    Enable/disable the Smagorinsky-Lilly subgrid-scale model.
                    """
                class les_subgrid_tke(TUIMethod):
                    """
                    Enable/disable the kinetic energy transport subgrid-scale model.
                    """
                class les_subgrid_vreman(TUIMethod):
                    """
                    Enable/disable the Vreman subgrid-scale model.
                    """
                class les_subgrid_wale(TUIMethod):
                    """
                    Enable/disable the WALE subgrid-scale model.
                    """
                class les_subgrid_wmles(TUIMethod):
                    """
                    Enable/disable the WMLES subgrid-scale model.
                    """
                class les_subgrid_wmles_s_minus_omega(TUIMethod):
                    """
                    Enable/disable the WMLES S-Omega subgrid-scale model.
                    """
                class low_pressure_boundary_slip(TUIMethod):
                    """
                    .
                    """
                class mixing_length(TUIMethod):
                    """
                    Enable/disable the mixing-length (algebraic) turbulence model.
                    """
                class reynolds_stress_model(TUIMethod):
                    """
                    Enable/disable the RSM turbulence model.
                    """
                class rng_differential_visc(TUIMethod):
                    """
                    .
                    """
                class rng_swirl_model(TUIMethod):
                    """
                    .
                    """
                class rsm_bsl_based(TUIMethod):
                    """
                    Enable/disable the Stress-BSL model.
                    """
                class rsm_linear_pressure_strain(TUIMethod):
                    """
                    Enable/disable the linear pressure-strain model in RSM.
                    """
                class rsm_omega_based(TUIMethod):
                    """
                    Enable/disable the Stress-omega model.
                    """
                class rsm_or_earsm_geko_option(TUIMethod):
                    """
                    .
                    """
                class rsm_solve_tke(TUIMethod):
                    """
                    .
                    """
                class rsm_ssg_pressure_strain(TUIMethod):
                    """
                    Enable/disable the quadratic pressure-strain model in RSM.
                    """
                class rsm_wall_echo(TUIMethod):
                    """
                    .
                    """
                class sa_alternate_prod(TUIMethod):
                    """
                    .
                    """
                class sa_damping(TUIMethod):
                    """
                    .
                    """
                class sa_enhanced_wall_treatment(TUIMethod):
                    """
                    .
                    """
                class sas(TUIMethod):
                    """
                    Enable/disable the SAS turbulence model.
                    """
                class spalart_allmaras(TUIMethod):
                    """
                    Enable/disable the Spalart-Allmaras turbulence model.
                    """
                class trans_sst_roughness_correlation(TUIMethod):
                    """
                    Enable/disable the Transition-SST roughness correlation option.
                    """
                class transition_sst(TUIMethod):
                    """
                    Enable/disable the transition SST turbulence model.
                    """
                class turb_buoyancy_effects(TUIMethod):
                    """
                    .
                    """
                class turb_compressibility(TUIMethod):
                    """
                    .
                    """
                class user_defined(TUIMethod):
                    """
                    Select user-defined functions to define the turbulent viscosity and the turbulent Prandtl and Schmidt numbers.
                    """
                class user_defined_transition(TUIMethod):
                    """
                    .
                    """
                class v2f(TUIMethod):
                    """
                    Enable/disable the V2F turbulence model.
                    """
                class zero_equation_hvac(TUIMethod):
                    """
                    Enable/disable the zero-equation HVAC turbulence model.
                    """

                class geko_options(TUIMenu):
                    """
                    Enter the GEKO options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.blending_function = self.__class__.blending_function(service, version, mode, path + ["blending_function"])
                        self.cbf_lam = self.__class__.cbf_lam(service, version, mode, path + ["cbf_lam"])
                        self.cbf_tur = self.__class__.cbf_tur(service, version, mode, path + ["cbf_tur"])
                        self.cjet = self.__class__.cjet(service, version, mode, path + ["cjet"])
                        self.cjet_aux = self.__class__.cjet_aux(service, version, mode, path + ["cjet_aux"])
                        self.cmix = self.__class__.cmix(service, version, mode, path + ["cmix"])
                        self.cnw = self.__class__.cnw(service, version, mode, path + ["cnw"])
                        self.cnw_sub = self.__class__.cnw_sub(service, version, mode, path + ["cnw_sub"])
                        self.creal = self.__class__.creal(service, version, mode, path + ["creal"])
                        self.csep = self.__class__.csep(service, version, mode, path + ["csep"])
                        self.geko_defaults = self.__class__.geko_defaults(service, version, mode, path + ["geko_defaults"])
                        self.version = self.__class__.version(service, version, mode, path + ["version"])
                        self.wall_distance_free = self.__class__.wall_distance_free(service, version, mode, path + ["wall_distance_free"])
                        super().__init__(service, version, mode, path)
                    class blending_function(TUIMethod):
                        """
                        Set the GEKO model blending function.
                        """
                    class cbf_lam(TUIMethod):
                        """
                        .
                        """
                    class cbf_tur(TUIMethod):
                        """
                        .
                        """
                    class cjet(TUIMethod):
                        """
                        .
                        """
                    class cjet_aux(TUIMethod):
                        """
                        .
                        """
                    class cmix(TUIMethod):
                        """
                        Set the GEKO model coefficient CMIX.
                        """
                    class cnw(TUIMethod):
                        """
                        Set the GEKO model coefficient CNW.
                        """
                    class cnw_sub(TUIMethod):
                        """
                        .
                        """
                    class creal(TUIMethod):
                        """
                        .
                        """
                    class csep(TUIMethod):
                        """
                        Set the GEKO model coefficient CSEP.
                        """
                    class geko_defaults(TUIMethod):
                        """
                        .
                        """
                    class version(TUIMethod):
                        """
                        .
                        """
                    class wall_distance_free(TUIMethod):
                        """
                        .
                        """

                class les_model_options(TUIMenu):
                    """
                    Enter the LES model options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.csigma = self.__class__.csigma(service, version, mode, path + ["csigma"])
                        self.cvreman = self.__class__.cvreman(service, version, mode, path + ["cvreman"])
                        self.cw1 = self.__class__.cw1(service, version, mode, path + ["cw1"])
                        self.cw2 = self.__class__.cw2(service, version, mode, path + ["cw2"])
                        self.near_wall_rans_layer = self.__class__.near_wall_rans_layer(service, version, mode, path + ["near_wall_rans_layer"])
                        super().__init__(service, version, mode, path)
                    class csigma(TUIMethod):
                        """
                        .
                        """
                    class cvreman(TUIMethod):
                        """
                        .
                        """
                    class cw1(TUIMethod):
                        """
                        .
                        """
                    class cw2(TUIMethod):
                        """
                        .
                        """
                    class near_wall_rans_layer(TUIMethod):
                        """
                        .
                        """

                class multiphase_turbulence(TUIMenu):
                    """
                    Enter the multiphase turbulence menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.multiphase_options = self.__class__.multiphase_options(service, version, mode, path + ["multiphase_options"])
                        self.rsm_multiphase_models = self.__class__.rsm_multiphase_models(service, version, mode, path + ["rsm_multiphase_models"])
                        self.subgrid_turbulence_contribution_aiad = self.__class__.subgrid_turbulence_contribution_aiad(service, version, mode, path + ["subgrid_turbulence_contribution_aiad"])
                        self.turbulence_multiphase_models = self.__class__.turbulence_multiphase_models(service, version, mode, path + ["turbulence_multiphase_models"])
                        super().__init__(service, version, mode, path)
                    class multiphase_options(TUIMethod):
                        """
                        .
                        """
                    class rsm_multiphase_models(TUIMethod):
                        """
                        Enable/disable the Reynolds Stress multiphase model.
                        """
                    class subgrid_turbulence_contribution_aiad(TUIMethod):
                        """
                        .
                        """
                    class turbulence_multiphase_models(TUIMethod):
                        """
                        Select the k-epsilon multiphase model.
                        """

                class near_wall_treatment(TUIMenu):
                    """
                    Enter the near wall treatment menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.enhanced_wall_treatment = self.__class__.enhanced_wall_treatment(service, version, mode, path + ["enhanced_wall_treatment"])
                        self.harmonic_blend_rplus_wf = self.__class__.harmonic_blend_rplus_wf(service, version, mode, path + ["harmonic_blend_rplus_wf"])
                        self.menter_lechner = self.__class__.menter_lechner(service, version, mode, path + ["menter_lechner"])
                        self.non_equilibrium_wall_fn = self.__class__.non_equilibrium_wall_fn(service, version, mode, path + ["non_equilibrium_wall_fn"])
                        self.scalable_wall_functions = self.__class__.scalable_wall_functions(service, version, mode, path + ["scalable_wall_functions"])
                        self.use_second_cell_off_a_wall_quantities = self.__class__.use_second_cell_off_a_wall_quantities(service, version, mode, path + ["use_second_cell_off_a_wall_quantities"])
                        self.user_defined_wall_functions = self.__class__.user_defined_wall_functions(service, version, mode, path + ["user_defined_wall_functions"])
                        self.wall_omega_treatment = self.__class__.wall_omega_treatment(service, version, mode, path + ["wall_omega_treatment"])
                        self.werner_wengle_wall_fn = self.__class__.werner_wengle_wall_fn(service, version, mode, path + ["werner_wengle_wall_fn"])
                        self.wf_pressure_gradient_effects = self.__class__.wf_pressure_gradient_effects(service, version, mode, path + ["wf_pressure_gradient_effects"])
                        self.wf_thermal_effects = self.__class__.wf_thermal_effects(service, version, mode, path + ["wf_thermal_effects"])
                        super().__init__(service, version, mode, path)
                    class enhanced_wall_treatment(TUIMethod):
                        """
                        Enable/disable enhanced wall functions.
                        """
                    class harmonic_blend_rplus_wf(TUIMethod):
                        """
                        Enable/disable harmonic blended wall functions based on r-plus.
                        """
                    class menter_lechner(TUIMethod):
                        """
                        Enable/disable near wall treatment Menter-Lechner.
                        """
                    class non_equilibrium_wall_fn(TUIMethod):
                        """
                        Enable/disable non-equilibrium wall functions.
                        """
                    class scalable_wall_functions(TUIMethod):
                        """
                        Enable/disable scalable wall functions.
                        """
                    class use_second_cell_off_a_wall_quantities(TUIMethod):
                        """
                        .
                        """
                    class user_defined_wall_functions(TUIMethod):
                        """
                        Enable user defined wall functions.
                        """
                    class wall_omega_treatment(TUIMethod):
                        """
                        .
                        """
                    class werner_wengle_wall_fn(TUIMethod):
                        """
                        Enable/disable Werner-Wengle wall functions.
                        """
                    class wf_pressure_gradient_effects(TUIMethod):
                        """
                        .
                        """
                    class wf_thermal_effects(TUIMethod):
                        """
                        .
                        """

                class transition_model_options(TUIMenu):
                    """
                    Enter the transition model options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.capg_hightu = self.__class__.capg_hightu(service, version, mode, path + ["capg_hightu"])
                        self.capg_lowtu = self.__class__.capg_lowtu(service, version, mode, path + ["capg_lowtu"])
                        self.cbubble_c1 = self.__class__.cbubble_c1(service, version, mode, path + ["cbubble_c1"])
                        self.cbubble_c2 = self.__class__.cbubble_c2(service, version, mode, path + ["cbubble_c2"])
                        self.cfpg_hightu = self.__class__.cfpg_hightu(service, version, mode, path + ["cfpg_hightu"])
                        self.cfpg_lowtu = self.__class__.cfpg_lowtu(service, version, mode, path + ["cfpg_lowtu"])
                        self.clambda_scale = self.__class__.clambda_scale(service, version, mode, path + ["clambda_scale"])
                        self.critical_reynolds_number_correlation = self.__class__.critical_reynolds_number_correlation(service, version, mode, path + ["critical_reynolds_number_correlation"])
                        self.crossflow_transition = self.__class__.crossflow_transition(service, version, mode, path + ["crossflow_transition"])
                        self.ctu_hightu = self.__class__.ctu_hightu(service, version, mode, path + ["ctu_hightu"])
                        self.ctu_lowtu = self.__class__.ctu_lowtu(service, version, mode, path + ["ctu_lowtu"])
                        self.rec_c1 = self.__class__.rec_c1(service, version, mode, path + ["rec_c1"])
                        self.rec_c2 = self.__class__.rec_c2(service, version, mode, path + ["rec_c2"])
                        self.rec_max = self.__class__.rec_max(service, version, mode, path + ["rec_max"])
                        self.rv1_switch = self.__class__.rv1_switch(service, version, mode, path + ["rv1_switch"])
                        super().__init__(service, version, mode, path)
                    class capg_hightu(TUIMethod):
                        """
                        .
                        """
                    class capg_lowtu(TUIMethod):
                        """
                        .
                        """
                    class cbubble_c1(TUIMethod):
                        """
                        .
                        """
                    class cbubble_c2(TUIMethod):
                        """
                        .
                        """
                    class cfpg_hightu(TUIMethod):
                        """
                        .
                        """
                    class cfpg_lowtu(TUIMethod):
                        """
                        .
                        """
                    class clambda_scale(TUIMethod):
                        """
                        .
                        """
                    class critical_reynolds_number_correlation(TUIMethod):
                        """
                        Set the critical Reynolds number correlation.
                        """
                    class crossflow_transition(TUIMethod):
                        """
                        .
                        """
                    class ctu_hightu(TUIMethod):
                        """
                        .
                        """
                    class ctu_lowtu(TUIMethod):
                        """
                        .
                        """
                    class rec_c1(TUIMethod):
                        """
                        .
                        """
                    class rec_c2(TUIMethod):
                        """
                        .
                        """
                    class rec_max(TUIMethod):
                        """
                        .
                        """
                    class rv1_switch(TUIMethod):
                        """
                        .
                        """

                class turbulence_expert(TUIMenu):
                    """
                    Enter the turbulence expert menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.curvature_correction_coefficient = self.__class__.curvature_correction_coefficient(service, version, mode, path + ["curvature_correction_coefficient"])
                        self.kato_launder_model = self.__class__.kato_launder_model(service, version, mode, path + ["kato_launder_model"])
                        self.kw_add_des = self.__class__.kw_add_des(service, version, mode, path + ["kw_add_des"])
                        self.kw_add_sas = self.__class__.kw_add_sas(service, version, mode, path + ["kw_add_sas"])
                        self.kw_vorticity_based_production = self.__class__.kw_vorticity_based_production(service, version, mode, path + ["kw_vorticity_based_production"])
                        self.low_re_ke = self.__class__.low_re_ke(service, version, mode, path + ["low_re_ke"])
                        self.low_re_ke_index = self.__class__.low_re_ke_index(service, version, mode, path + ["low_re_ke_index"])
                        self.non_newtonian_modification = self.__class__.non_newtonian_modification(service, version, mode, path + ["non_newtonian_modification"])
                        self.production_limiter = self.__class__.production_limiter(service, version, mode, path + ["production_limiter"])
                        self.restore_sst_v61 = self.__class__.restore_sst_v61(service, version, mode, path + ["restore_sst_v61"])
                        self.rke_cmu_rotation_term = self.__class__.rke_cmu_rotation_term(service, version, mode, path + ["rke_cmu_rotation_term"])
                        self.sbes_les_subgrid_dynamic_fvar = self.__class__.sbes_les_subgrid_dynamic_fvar(service, version, mode, path + ["sbes_les_subgrid_dynamic_fvar"])
                        self.sbes_sdes_hybrid_model = self.__class__.sbes_sdes_hybrid_model(service, version, mode, path + ["sbes_sdes_hybrid_model"])
                        self.sbes_sgs_option = self.__class__.sbes_sgs_option(service, version, mode, path + ["sbes_sgs_option"])
                        self.sbes_update_interval_k_omega = self.__class__.sbes_update_interval_k_omega(service, version, mode, path + ["sbes_update_interval_k_omega"])
                        self.thermal_p_function = self.__class__.thermal_p_function(service, version, mode, path + ["thermal_p_function"])
                        self.turb_add_sbes_sdes = self.__class__.turb_add_sbes_sdes(service, version, mode, path + ["turb_add_sbes_sdes"])
                        self.turb_non_newtonian = self.__class__.turb_non_newtonian(service, version, mode, path + ["turb_non_newtonian"])
                        self.turb_pk_compressible = self.__class__.turb_pk_compressible(service, version, mode, path + ["turb_pk_compressible"])
                        self.turbulence_damping = self.__class__.turbulence_damping(service, version, mode, path + ["turbulence_damping"])
                        super().__init__(service, version, mode, path)
                    class curvature_correction_coefficient(TUIMethod):
                        """
                        Set the strength of the curvature correction term. The default value is 1.
                        """
                    class kato_launder_model(TUIMethod):
                        """
                        .
                        """
                    class kw_add_des(TUIMethod):
                        """
                        .
                        """
                    class kw_add_sas(TUIMethod):
                        """
                        .
                        """
                    class kw_vorticity_based_production(TUIMethod):
                        """
                        .
                        """
                    class low_re_ke(TUIMethod):
                        """
                        Enable/disable the low-Re k-epsilon turbulence model.
                        """
                    class low_re_ke_index(TUIMethod):
                        """
                        Enable/disable the low-Re k-epsilon model version.
                        """
                    class non_newtonian_modification(TUIMethod):
                        """
                        .
                        """
                    class production_limiter(TUIMethod):
                        """
                        .
                        """
                    class restore_sst_v61(TUIMethod):
                        """
                        .
                        """
                    class rke_cmu_rotation_term(TUIMethod):
                        """
                        .
                        """
                    class sbes_les_subgrid_dynamic_fvar(TUIMethod):
                        """
                        .
                        """
                    class sbes_sdes_hybrid_model(TUIMethod):
                        """
                        Select the SBES / SDES hybrid model.
                        """
                    class sbes_sgs_option(TUIMethod):
                        """
                        Select SBES subgrid-scale model.
                        """
                    class sbes_update_interval_k_omega(TUIMethod):
                        """
                        Set an integer value how often the k and omega equations are updated in a transient SBES run.
                        """
                    class thermal_p_function(TUIMethod):
                        """
                        .
                        """
                    class turb_add_sbes_sdes(TUIMethod):
                        """
                        Enable/disable SBES / SDES with the current turbulence model.
                        """
                    class turb_non_newtonian(TUIMethod):
                        """
                        .
                        """
                    class turb_pk_compressible(TUIMethod):
                        """
                        .
                        """
                    class turbulence_damping(TUIMethod):
                        """
                        .
                        """

        class motion_definitions(TUIMenu):
            """
            Manage motion definitions.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """

        class named_expressions(TUIMenu):
            """
            Manage named expressions.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.compute = self.__class__.compute(service, version, mode, path + ["compute"])
                self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.export_to_tsv = self.__class__.export_to_tsv(service, version, mode, path + ["export_to_tsv"])
                self.import_from_tsv = self.__class__.import_from_tsv(service, version, mode, path + ["import_from_tsv"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class compute(TUIMethod):
                """
                Compute expression.
                """
            class copy(TUIMethod):
                """
                Copy expression.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class export_to_tsv(TUIMethod):
                """
                Export expressions.
                """
            class import_from_tsv(TUIMethod):
                """
                Import expressions.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """

        class operating_conditions(TUIMenu):
            """
            Enter the define operating conditions menu.
            """
            def __init__(self, service, version, mode, path):
                self.operating_density = self.__class__.operating_density(service, version, mode, path + ["operating_density"])
                self.floating_operating_pressure = self.__class__.floating_operating_pressure(service, version, mode, path + ["floating_operating_pressure"])
                self.gravity = self.__class__.gravity(service, version, mode, path + ["gravity"])
                self.gravity_mrf_behavior = self.__class__.gravity_mrf_behavior(service, version, mode, path + ["gravity_mrf_behavior"])
                self.operating_pressure = self.__class__.operating_pressure(service, version, mode, path + ["operating_pressure"])
                self.operating_temperature = self.__class__.operating_temperature(service, version, mode, path + ["operating_temperature"])
                self.reference_pressure_location = self.__class__.reference_pressure_location(service, version, mode, path + ["reference_pressure_location"])
                self.reference_pressure_method = self.__class__.reference_pressure_method(service, version, mode, path + ["reference_pressure_method"])
                self.set_state = self.__class__.set_state(service, version, mode, path + ["set_state"])
                self.use_inlet_temperature_for_operating_density = self.__class__.use_inlet_temperature_for_operating_density(service, version, mode, path + ["use_inlet_temperature_for_operating_density"])
                self.used_ref_pressure_location = self.__class__.used_ref_pressure_location(service, version, mode, path + ["used_ref_pressure_location"])
                super().__init__(service, version, mode, path)
            class operating_density(TUIMethod):
                """
                Multiphase flow Operating Density menu.
                """
            class floating_operating_pressure(TUIMethod):
                """
                Enable/disable use of the floating operating pressure.
                """
            class gravity(TUIMethod):
                """
                .
                """
            class gravity_mrf_behavior(TUIMethod):
                """
                .
                """
            class operating_pressure(TUIMethod):
                """
                .
                """
            class operating_temperature(TUIMethod):
                """
                .
                """
            class reference_pressure_location(TUIMethod):
                """
                .
                """
            class reference_pressure_method(TUIMethod):
                """
                .
                """
            class set_state(TUIMethod):
                """
                .
                """
            class use_inlet_temperature_for_operating_density(TUIMethod):
                """
                .
                """
            class used_ref_pressure_location(TUIMethod):
                """
                .
                """

        class overset_interfaces(TUIMenu):
            """
            Enter the overset-interfaces menu.
            """
            def __init__(self, service, version, mode, path):
                self.adapt = self.__class__.adapt(service, version, mode, path + ["adapt"])
                self.cut_control = self.__class__.cut_control(service, version, mode, path + ["cut_control"])
                self.options = self.__class__.options(service, version, mode, path + ["options"])
                self.check = self.__class__.check(service, version, mode, path + ["check"])
                self.clear = self.__class__.clear(service, version, mode, path + ["clear"])
                self.clear_all = self.__class__.clear_all(service, version, mode, path + ["clear_all"])
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.debug_hole_cut = self.__class__.debug_hole_cut(service, version, mode, path + ["debug_hole_cut"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                self.display_cells = self.__class__.display_cells(service, version, mode, path + ["display_cells"])
                self.fill_dci = self.__class__.fill_dci(service, version, mode, path + ["fill_dci"])
                self.find_all_bounding_cells = self.__class__.find_all_bounding_cells(service, version, mode, path + ["find_all_bounding_cells"])
                self.find_bounding_cell = self.__class__.find_bounding_cell(service, version, mode, path + ["find_bounding_cell"])
                self.free_dci = self.__class__.free_dci(service, version, mode, path + ["free_dci"])
                self.grid_priorities = self.__class__.grid_priorities(service, version, mode, path + ["grid_priorities"])
                self.intersect = self.__class__.intersect(service, version, mode, path + ["intersect"])
                self.intersect_all = self.__class__.intersect_all(service, version, mode, path + ["intersect_all"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.mark_cell_change = self.__class__.mark_cell_change(service, version, mode, path + ["mark_cell_change"])
                self.mark_cells = self.__class__.mark_cells(service, version, mode, path + ["mark_cells"])
                self.read_dci_from_case = self.__class__.read_dci_from_case(service, version, mode, path + ["read_dci_from_case"])
                self.set_mark_bounds = self.__class__.set_mark_bounds(service, version, mode, path + ["set_mark_bounds"])
                self.update_from_dci = self.__class__.update_from_dci(service, version, mode, path + ["update_from_dci"])
                self.write_cell_types = self.__class__.write_cell_types(service, version, mode, path + ["write_cell_types"])
                self.write_dci = self.__class__.write_dci(service, version, mode, path + ["write_dci"])
                self.write_dci_to_case = self.__class__.write_dci_to_case(service, version, mode, path + ["write_dci_to_case"])
                super().__init__(service, version, mode, path)
            class check(TUIMethod):
                """
                Check all overset interfaces.
                """
            class clear(TUIMethod):
                """
                Clear an overset interface.
                """
            class clear_all(TUIMethod):
                """
                Clear all overset interfaces.
                """
            class create(TUIMethod):
                """
                Create an overset interface.
                """
            class debug_hole_cut(TUIMethod):
                """
                Debugging tool for overset hole cutting.
                """
            class delete(TUIMethod):
                """
                Delete an overset interface.
                """
            class delete_all(TUIMethod):
                """
                Delete all overset interfaces.
                """
            class display_cells(TUIMethod):
                """
                Display the marked overset cells.
                """
            class fill_dci(TUIMethod):
                """
                Fill overset domain connectivity information (DCI).
                """
            class find_all_bounding_cells(TUIMethod):
                """
                Find bounding cells for all cell centroids.
                """
            class find_bounding_cell(TUIMethod):
                """
                Find bounding cell for given cell or search point.
                """
            class free_dci(TUIMethod):
                """
                Free overset domain connectivity information (DCI).
                """
            class grid_priorities(TUIMethod):
                """
                Edit grid priorities for an overset interface.
                """
            class intersect(TUIMethod):
                """
                Intersect an overset interface.
                """
            class intersect_all(TUIMethod):
                """
                Intersect all overset interfaces.
                """
            class list(TUIMethod):
                """
                List all overset interfaces.
                """
            class mark_cell_change(TUIMethod):
                """
                Mark overset interface related cell type change.
                """
            class mark_cells(TUIMethod):
                """
                Mark overset interface related cell types.
                """
            class read_dci_from_case(TUIMethod):
                """
                Read domain connectivity information (DCI) from case file.
                """
            class set_mark_bounds(TUIMethod):
                """
                Set bounds (center, radius) for overset cell marking.
                """
            class update_from_dci(TUIMethod):
                """
                Update all overset intrfaces from stored domain connectivity information (DCI).
                """
            class write_cell_types(TUIMethod):
                """
                Write overset cell types into file.
                """
            class write_dci(TUIMethod):
                """
                Save domain connectivity information (DCI) to a text file.
                """
            class write_dci_to_case(TUIMethod):
                """
                Save domain connectivity information (DCI) to case file.
                """

            class adapt(TUIMenu):
                """
                Enter the overset adaption menu.
                """
                def __init__(self, service, version, mode, path):
                    self.set = self.__class__.set(service, version, mode, path + ["set"])
                    self.adapt_mesh = self.__class__.adapt_mesh(service, version, mode, path + ["adapt_mesh"])
                    self.mark_adaption = self.__class__.mark_adaption(service, version, mode, path + ["mark_adaption"])
                    super().__init__(service, version, mode, path)
                class adapt_mesh(TUIMethod):
                    """
                    Mark and adapt the mesh to remove orphan cells and large donor-receptor cell size differences.
                    """
                class mark_adaption(TUIMethod):
                    """
                    Mark cells for overset orphan adaption and donor-receptor size differences.
                    """

                class set(TUIMenu):
                    """
                    Enter the overset adaption set menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.adaption_sweeps = self.__class__.adaption_sweeps(service, version, mode, path + ["adaption_sweeps"])
                        self.automatic = self.__class__.automatic(service, version, mode, path + ["automatic"])
                        self.buffer_layers = self.__class__.buffer_layers(service, version, mode, path + ["buffer_layers"])
                        self.gap_resolution = self.__class__.gap_resolution(service, version, mode, path + ["gap_resolution"])
                        self.length_ratio_max = self.__class__.length_ratio_max(service, version, mode, path + ["length_ratio_max"])
                        self.mark_coarsening = self.__class__.mark_coarsening(service, version, mode, path + ["mark_coarsening"])
                        self.mark_fixed_orphans = self.__class__.mark_fixed_orphans(service, version, mode, path + ["mark_fixed_orphans"])
                        self.mark_gaps = self.__class__.mark_gaps(service, version, mode, path + ["mark_gaps"])
                        self.mark_orphans = self.__class__.mark_orphans(service, version, mode, path + ["mark_orphans"])
                        self.mark_size = self.__class__.mark_size(service, version, mode, path + ["mark_size"])
                        self.maximum_refinement_level = self.__class__.maximum_refinement_level(service, version, mode, path + ["maximum_refinement_level"])
                        self.prismatic = self.__class__.prismatic(service, version, mode, path + ["prismatic"])
                        super().__init__(service, version, mode, path)
                    class adaption_sweeps(TUIMethod):
                        """
                        Set the number of adaption sweeps per overset adaption.
                        """
                    class automatic(TUIMethod):
                        """
                        Enable the option to automatically adapt overset meshes during solution update.
                        """
                    class buffer_layers(TUIMethod):
                        """
                        Set the number of cell layers marked in addition to the cells marked for orphan adaption.
                        """
                    class gap_resolution(TUIMethod):
                        """
                        Set the target (minimum) gap resolution used when marking cells for gap adaption.
                        """
                    class length_ratio_max(TUIMethod):
                        """
                        Set the length scale ratio threshold used to determine which cells are marked for adaption based on donor-receptor cell size differences.
                        """
                    class mark_coarsening(TUIMethod):
                        """
                        Enable the option to coarsen the mesh during overset adaption.
                        """
                    class mark_fixed_orphans(TUIMethod):
                        """
                        Enable the option to adapt for orphans which were removed by accepting neighbor donors.
                        """
                    class mark_gaps(TUIMethod):
                        """
                        Enable the option to adapt underresolved gaps.
                        """
                    class mark_orphans(TUIMethod):
                        """
                        Enable the option to adapt for orphan reduction.
                        """
                    class mark_size(TUIMethod):
                        """
                        Enable the option to adapt for donor-receptor cell size differences.
                        """
                    class maximum_refinement_level(TUIMethod):
                        """
                        Set the maximum level of refinement in overset adaption.
                        """
                    class prismatic(TUIMethod):
                        """
                        Enable the option to use anisotropic adaption in prismatic cells.
                        """

            class cut_control(TUIMenu):
                """
                Enter the overset hole cut control menu.
                """
                def __init__(self, service, version, mode, path):
                    self.cut_seeds = self.__class__.cut_seeds(service, version, mode, path + ["cut_seeds"])
                    self.add = self.__class__.add(service, version, mode, path + ["add"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    super().__init__(service, version, mode, path)
                class add(TUIMethod):
                    """
                    Add hole cut control for a boundary zone.
                    """
                class delete(TUIMethod):
                    """
                    Delete hole cut control for a boundary zone.
                    """
                class delete_all(TUIMethod):
                    """
                    Delete the hole cut controls for all boundary zones.
                    """
                class list(TUIMethod):
                    """
                    List the defined hole cut controls.
                    """

                class cut_seeds(TUIMenu):
                    """
                    Enter the overset hole cut seed menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.add = self.__class__.add(service, version, mode, path + ["add"])
                        self.cut_seeds_for_all_component_zones = self.__class__.cut_seeds_for_all_component_zones(service, version, mode, path + ["cut_seeds_for_all_component_zones"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        super().__init__(service, version, mode, path)
                    class add(TUIMethod):
                        """
                        Add a hole cut seed.
                        """
                    class cut_seeds_for_all_component_zones(TUIMethod):
                        """
                        Enable that all component zones get a cut seed.
                        """
                    class delete(TUIMethod):
                        """
                        Delete a hole cut seed.
                        """
                    class delete_all(TUIMethod):
                        """
                        Delete all hole cut seeds.
                        """
                    class list(TUIMethod):
                        """
                        List the defined hole cut seeds.
                        """

            class options(TUIMenu):
                """
                Enter the overset interface options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.auto_create = self.__class__.auto_create(service, version, mode, path + ["auto_create"])
                    self.dead_cell_update = self.__class__.dead_cell_update(service, version, mode, path + ["dead_cell_update"])
                    self.donor_priority_method = self.__class__.donor_priority_method(service, version, mode, path + ["donor_priority_method"])
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.mesh_interfaces = self.__class__.mesh_interfaces(service, version, mode, path + ["mesh_interfaces"])
                    self.minimize_overlap = self.__class__.minimize_overlap(service, version, mode, path + ["minimize_overlap"])
                    self.modified_donor_search = self.__class__.modified_donor_search(service, version, mode, path + ["modified_donor_search"])
                    self.modified_hole_cutting = self.__class__.modified_hole_cutting(service, version, mode, path + ["modified_hole_cutting"])
                    self.node_connected_donors = self.__class__.node_connected_donors(service, version, mode, path + ["node_connected_donors"])
                    self.overlap_boundaries = self.__class__.overlap_boundaries(service, version, mode, path + ["overlap_boundaries"])
                    self.parallel = self.__class__.parallel(service, version, mode, path + ["parallel"])
                    self.partial_cut_faces = self.__class__.partial_cut_faces(service, version, mode, path + ["partial_cut_faces"])
                    self.render_receptor_cells = self.__class__.render_receptor_cells(service, version, mode, path + ["render_receptor_cells"])
                    self.solve_island_removal = self.__class__.solve_island_removal(service, version, mode, path + ["solve_island_removal"])
                    self.transient_caching = self.__class__.transient_caching(service, version, mode, path + ["transient_caching"])
                    self.update_before_case_write = self.__class__.update_before_case_write(service, version, mode, path + ["update_before_case_write"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class auto_create(TUIMethod):
                    """
                    Enable automatic creation of default overset interface.
                    """
                class dead_cell_update(TUIMethod):
                    """
                    Enable dead cell update in moving or dynamic mesh simulations.
                    """
                class donor_priority_method(TUIMethod):
                    """
                    Set method used to evaludate the cell donor priority.
                    """
                class expert(TUIMethod):
                    """
                    Enable additional overset options and tools.
                    """
                class mesh_interfaces(TUIMethod):
                    """
                    Allow mesh interfaces inside overset cell zones.
                    """
                class minimize_overlap(TUIMethod):
                    """
                    Enable overlap minimization for overset interfaces.
                    """
                class modified_donor_search(TUIMethod):
                    """
                    Enable modified and more extensive donor search.
                    """
                class modified_hole_cutting(TUIMethod):
                    """
                    Enable modified hole cutting parameters.
                    """
                class node_connected_donors(TUIMethod):
                    """
                    Enable node or face connected donor cells.
                    """
                class overlap_boundaries(TUIMethod):
                    """
                    Enable overset topologies with overlap boundaries.
                    """
                class parallel(TUIMethod):
                    """
                    Set options to control running overset in parallel.
                    """
                class partial_cut_faces(TUIMethod):
                    """
                    Enable enhanced hole cutting where cut faces partially overlap.
                    """
                class render_receptor_cells(TUIMethod):
                    """
                    Set the option to include receptor cells in postprocessing.
                    """
                class solve_island_removal(TUIMethod):
                    """
                    Set method used to control the removal of isolated patches of solve cells.
                    """
                class transient_caching(TUIMethod):
                    """
                    Set options to control caching of entities in transient overset simulations.
                    """
                class update_before_case_write(TUIMethod):
                    """
                    Enable update of overset interfaces before writing case file (CFF format only).
                    """
                class verbosity(TUIMethod):
                    """
                    Set overset mesh reporting verbosity.
                    """

        class parameters(TUIMenu):
            """
            Enter the parameters menu.
            """
            def __init__(self, service, version, mode, path):
                self.input_parameters = self.__class__.input_parameters(service, version, mode, path + ["input_parameters"])
                self.list_parameters = self.__class__.list_parameters(service, version, mode, path + ["list_parameters"])
                self.output_parameters = self.__class__.output_parameters(service, version, mode, path + ["output_parameters"])
                self.enable_in_TUI = self.__class__.enable_in_TUI(service, version, mode, path + ["enable_in_TUI"])
                super().__init__(service, version, mode, path)
            class enable_in_TUI(TUIMethod):
                """
                .
                """

            class input_parameters(TUIMenu):
                """
                Enter the input-parameters menu.
                """
                def __init__(self, service, version, mode, path):
                    self.advance = self.__class__.advance(service, version, mode, path + ["advance"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    super().__init__(service, version, mode, path)
                class delete(TUIMethod):
                    """
                    Delete an input parameter.
                    """
                class edit(TUIMethod):
                    """
                    Edit an input parameter.
                    """

                class advance(TUIMenu):
                    """
                    Define custom variable to use input parameter.
                    """
                    def __init__(self, service, version, mode, path):
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.use_in = self.__class__.use_in(service, version, mode, path + ["use_in"])
                        super().__init__(service, version, mode, path)
                    class delete(TUIMethod):
                        """
                        Delete selected custom-input-parameters.
                        """
                    class list(TUIMethod):
                        """
                        List of custom-input-parameters.
                        """
                    class use_in(TUIMethod):
                        """
                        Use input parameter in solver-udf or in scheme-procedure.
                        """

            class list_parameters(TUIMenu):
                """
                Enter list-param menu.
                """
                def __init__(self, service, version, mode, path):
                    self.input_parameters = self.__class__.input_parameters(service, version, mode, path + ["input_parameters"])
                    self.output_parameters = self.__class__.output_parameters(service, version, mode, path + ["output_parameters"])
                    super().__init__(service, version, mode, path)
                class input_parameters(TUIMethod):
                    """
                    .
                    """
                class output_parameters(TUIMethod):
                    """
                    .
                    """

            class output_parameters(TUIMenu):
                """
                Enter the output-parameters menu.
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.print_all_to_console = self.__class__.print_all_to_console(service, version, mode, path + ["print_all_to_console"])
                    self.print_to_console = self.__class__.print_to_console(service, version, mode, path + ["print_to_console"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    self.write_all_to_file = self.__class__.write_all_to_file(service, version, mode, path + ["write_all_to_file"])
                    self.write_to_file = self.__class__.write_to_file(service, version, mode, path + ["write_to_file"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    Create an output parameter.
                    """
                class delete(TUIMethod):
                    """
                    Delete an output parameter.
                    """
                class edit(TUIMethod):
                    """
                    Edit an output parameter.
                    """
                class print_all_to_console(TUIMethod):
                    """
                    Print all parameter values to console.
                    """
                class print_to_console(TUIMethod):
                    """
                    Print parameter value to console.
                    """
                class rename(TUIMethod):
                    """
                    Rename an output parameter.
                    """
                class write_all_to_file(TUIMethod):
                    """
                    Write all parameter values to file.
                    """
                class write_to_file(TUIMethod):
                    """
                    Write parameter value to file.
                    """

        class periodic_conditions(TUIMenu):
            """
            Enter the periodic conditions menu.
            """
            def __init__(self, service, version, mode, path):
                self.massflow_rate_specification = self.__class__.massflow_rate_specification(service, version, mode, path + ["massflow_rate_specification"])
                self.pressure_gradient_specification = self.__class__.pressure_gradient_specification(service, version, mode, path + ["pressure_gradient_specification"])
                super().__init__(service, version, mode, path)
            class massflow_rate_specification(TUIMethod):
                """
                Enable/disable specification of mass flow rate at the periodic boundary.
                """
            class pressure_gradient_specification(TUIMethod):
                """
                Enable/disable specification of pressure gradient at the periodic boundary.
                """

        class phases(TUIMenu):
            """
            Enter the phases menu.
            """
            def __init__(self, service, version, mode, path):
                self.iac_expert = self.__class__.iac_expert(service, version, mode, path + ["iac_expert"])
                self.set_domain_properties = self.__class__.set_domain_properties(service, version, mode, path + ["set_domain_properties"])
                self.interaction_domain = self.__class__.interaction_domain(service, version, mode, path + ["interaction_domain"])
                self.phase_domain = self.__class__.phase_domain(service, version, mode, path + ["phase_domain"])
                super().__init__(service, version, mode, path)
            class interaction_domain(TUIMethod):
                """
                Enter the menu to set interaction domain properties.
                """
            class phase_domain(TUIMethod):
                """
                Enter the menu to set phase domain properties.
                """

            class iac_expert(TUIMenu):
                """
                Enter the IAC expert setting menu.
                """
                def __init__(self, service, version, mode, path):
                    self.hibiki_ishii_model = self.__class__.hibiki_ishii_model(service, version, mode, path + ["hibiki_ishii_model"])
                    self.iac_pseudo_time_step = self.__class__.iac_pseudo_time_step(service, version, mode, path + ["iac_pseudo_time_step"])
                    self.ishii_kim_model = self.__class__.ishii_kim_model(service, version, mode, path + ["ishii_kim_model"])
                    self.yao_morel_model = self.__class__.yao_morel_model(service, version, mode, path + ["yao_morel_model"])
                    super().__init__(service, version, mode, path)
                class hibiki_ishii_model(TUIMethod):
                    """
                    Set hi model coefficients.
                    """
                class iac_pseudo_time_step(TUIMethod):
                    """
                    Set iac pseudo-time.
                    """
                class ishii_kim_model(TUIMethod):
                    """
                    Set ik model coefficients.
                    """
                class yao_morel_model(TUIMethod):
                    """
                    Set ym model coefficients.
                    """

            class set_domain_properties(TUIMenu):
                """
                Enter the menu to set domain properties.
                """
                def __init__(self, service, version, mode, path):
                    self.interaction_domain = self.__class__.interaction_domain(service, version, mode, path + ["interaction_domain"])
                    self.change_phases_names = self.__class__.change_phases_names(service, version, mode, path + ["change_phases_names"])
                    self.phase_domains = self.__class__.phase_domains(service, version, mode, path + ["phase_domains"])
                    super().__init__(service, version, mode, path)
                class change_phases_names(TUIMethod):
                    """
                    Change names for all defined phases?.
                    """
                class phase_domains(TUIMethod):
                    """
                    Enter the menu to select a specific phase domain.
                    """

                class interaction_domain(TUIMenu):
                    """
                    Enter the menu to set the interaction domain properties.
                    """
                    def __init__(self, service, version, mode, path):
                        self.forces = self.__class__.forces(service, version, mode, path + ["forces"])
                        self.heat_mass_reactions = self.__class__.heat_mass_reactions(service, version, mode, path + ["heat_mass_reactions"])
                        self.interfacial_area = self.__class__.interfacial_area(service, version, mode, path + ["interfacial_area"])
                        self.model_transition = self.__class__.model_transition(service, version, mode, path + ["model_transition"])
                        self.numerics = self.__class__.numerics(service, version, mode, path + ["numerics"])
                        super().__init__(service, version, mode, path)

                    class forces(TUIMenu):
                        """
                        Enter the menu to set interfacial forces related models.
                        """
                        def __init__(self, service, version, mode, path):
                            self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                            self.interphase_discretization = self.__class__.interphase_discretization(service, version, mode, path + ["interphase_discretization"])
                            self.interphase_viscous_dissipation = self.__class__.interphase_viscous_dissipation(service, version, mode, path + ["interphase_viscous_dissipation"])
                            self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                            self.surface_tension = self.__class__.surface_tension(service, version, mode, path + ["surface_tension"])
                            self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                            self.drag = self.__class__.drag(service, version, mode, path + ["drag"])
                            self.heat_coeff = self.__class__.heat_coeff(service, version, mode, path + ["heat_coeff"])
                            self.interfacial_area = self.__class__.interfacial_area(service, version, mode, path + ["interfacial_area"])
                            self.mass_transfer = self.__class__.mass_transfer(service, version, mode, path + ["mass_transfer"])
                            self.model_transition = self.__class__.model_transition(service, version, mode, path + ["model_transition"])
                            self.reactions = self.__class__.reactions(service, version, mode, path + ["reactions"])
                            self.restitution = self.__class__.restitution(service, version, mode, path + ["restitution"])
                            self.slip_velocity = self.__class__.slip_velocity(service, version, mode, path + ["slip_velocity"])
                            self.turbulence_interaction = self.__class__.turbulence_interaction(service, version, mode, path + ["turbulence_interaction"])
                            self.turbulent_dispersion = self.__class__.turbulent_dispersion(service, version, mode, path + ["turbulent_dispersion"])
                            self.wall_lubrication = self.__class__.wall_lubrication(service, version, mode, path + ["wall_lubrication"])
                            super().__init__(service, version, mode, path)
                        class drag(TUIMethod):
                            """
                            Specify the drag function for each pair of phases. It also enables drag modification and allow specifying the drag factor.
                            """
                        class heat_coeff(TUIMethod):
                            """
                            Specify the heat transfer coefficient function between each pair of phases.
                            """
                        class interfacial_area(TUIMethod):
                            """
                            Set the interfacial area parameters for each pair of phases.
                            """
                        class mass_transfer(TUIMethod):
                            """
                            Specify the mass transfer mechanisms.
                            """
                        class model_transition(TUIMethod):
                            """
                            Set the model transition mechanism.
                            """
                        class reactions(TUIMethod):
                            """
                            Define multiple heterogeneous reactions and stoichiometry.
                            """
                        class restitution(TUIMethod):
                            """
                            Specify the restitution coefficient for collisions between each pair of granular phases and for collisions between particles of the same granular phase.
                            """
                        class slip_velocity(TUIMethod):
                            """
                            Specify the slip velocity function for each secondary phase with respect to the primary phase.
                            """
                        class turbulence_interaction(TUIMethod):
                            """
                            Specify the turbulence interaction model for each primary-secondary phase pair.
                            """
                        class turbulent_dispersion(TUIMethod):
                            """
                            Specify the turbulent dispersion model for each primary-secondary phase pair.
                            """
                        class wall_lubrication(TUIMethod):
                            """
                            Specify the wall lubrication model for each primary-secondary phase pair.
                            """

                        class cavitation(TUIMenu):
                            """
                            Enter the menu to set cavitation models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_discretization(TUIMenu):
                            """
                            Enter the menu to set interphase discretization models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_viscous_dissipation(TUIMenu):
                            """
                            Enter the menu to set interphase viscous dissipation related models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class lift(TUIMenu):
                            """
                            Enter the menu to set lift models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class surface_tension(TUIMenu):
                            """
                            Enter the menu to set surface tension models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class virtual_mass(TUIMenu):
                            """
                            Enter the menu to set virtual mass models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                    class heat_mass_reactions(TUIMenu):
                        """
                        Enter the menu to set heat, mass-transfer, or reaction related models.
                        """
                        def __init__(self, service, version, mode, path):
                            self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                            self.interphase_discretization = self.__class__.interphase_discretization(service, version, mode, path + ["interphase_discretization"])
                            self.interphase_viscous_dissipation = self.__class__.interphase_viscous_dissipation(service, version, mode, path + ["interphase_viscous_dissipation"])
                            self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                            self.surface_tension = self.__class__.surface_tension(service, version, mode, path + ["surface_tension"])
                            self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                            self.drag = self.__class__.drag(service, version, mode, path + ["drag"])
                            self.heat_coeff = self.__class__.heat_coeff(service, version, mode, path + ["heat_coeff"])
                            self.interfacial_area = self.__class__.interfacial_area(service, version, mode, path + ["interfacial_area"])
                            self.mass_transfer = self.__class__.mass_transfer(service, version, mode, path + ["mass_transfer"])
                            self.model_transition = self.__class__.model_transition(service, version, mode, path + ["model_transition"])
                            self.reactions = self.__class__.reactions(service, version, mode, path + ["reactions"])
                            self.restitution = self.__class__.restitution(service, version, mode, path + ["restitution"])
                            self.slip_velocity = self.__class__.slip_velocity(service, version, mode, path + ["slip_velocity"])
                            self.turbulence_interaction = self.__class__.turbulence_interaction(service, version, mode, path + ["turbulence_interaction"])
                            self.turbulent_dispersion = self.__class__.turbulent_dispersion(service, version, mode, path + ["turbulent_dispersion"])
                            self.wall_lubrication = self.__class__.wall_lubrication(service, version, mode, path + ["wall_lubrication"])
                            super().__init__(service, version, mode, path)
                        class drag(TUIMethod):
                            """
                            Specify the drag function for each pair of phases. It also enables drag modification and allow specifying the drag factor.
                            """
                        class heat_coeff(TUIMethod):
                            """
                            Specify the heat transfer coefficient function between each pair of phases.
                            """
                        class interfacial_area(TUIMethod):
                            """
                            Set the interfacial area parameters for each pair of phases.
                            """
                        class mass_transfer(TUIMethod):
                            """
                            Specify the mass transfer mechanisms.
                            """
                        class model_transition(TUIMethod):
                            """
                            Set the model transition mechanism.
                            """
                        class reactions(TUIMethod):
                            """
                            Define multiple heterogeneous reactions and stoichiometry.
                            """
                        class restitution(TUIMethod):
                            """
                            Specify the restitution coefficient for collisions between each pair of granular phases and for collisions between particles of the same granular phase.
                            """
                        class slip_velocity(TUIMethod):
                            """
                            Specify the slip velocity function for each secondary phase with respect to the primary phase.
                            """
                        class turbulence_interaction(TUIMethod):
                            """
                            Specify the turbulence interaction model for each primary-secondary phase pair.
                            """
                        class turbulent_dispersion(TUIMethod):
                            """
                            Specify the turbulent dispersion model for each primary-secondary phase pair.
                            """
                        class wall_lubrication(TUIMethod):
                            """
                            Specify the wall lubrication model for each primary-secondary phase pair.
                            """

                        class cavitation(TUIMenu):
                            """
                            Enter the menu to set cavitation models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_discretization(TUIMenu):
                            """
                            Enter the menu to set interphase discretization models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_viscous_dissipation(TUIMenu):
                            """
                            Enter the menu to set interphase viscous dissipation related models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class lift(TUIMenu):
                            """
                            Enter the menu to set lift models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class surface_tension(TUIMenu):
                            """
                            Enter the menu to set surface tension models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class virtual_mass(TUIMenu):
                            """
                            Enter the menu to set virtual mass models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                    class interfacial_area(TUIMenu):
                        """
                        Enter the menu to set interfacial area models.
                        """
                        def __init__(self, service, version, mode, path):
                            self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                            self.interphase_discretization = self.__class__.interphase_discretization(service, version, mode, path + ["interphase_discretization"])
                            self.interphase_viscous_dissipation = self.__class__.interphase_viscous_dissipation(service, version, mode, path + ["interphase_viscous_dissipation"])
                            self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                            self.surface_tension = self.__class__.surface_tension(service, version, mode, path + ["surface_tension"])
                            self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                            self.drag = self.__class__.drag(service, version, mode, path + ["drag"])
                            self.heat_coeff = self.__class__.heat_coeff(service, version, mode, path + ["heat_coeff"])
                            self.interfacial_area = self.__class__.interfacial_area(service, version, mode, path + ["interfacial_area"])
                            self.mass_transfer = self.__class__.mass_transfer(service, version, mode, path + ["mass_transfer"])
                            self.model_transition = self.__class__.model_transition(service, version, mode, path + ["model_transition"])
                            self.reactions = self.__class__.reactions(service, version, mode, path + ["reactions"])
                            self.restitution = self.__class__.restitution(service, version, mode, path + ["restitution"])
                            self.slip_velocity = self.__class__.slip_velocity(service, version, mode, path + ["slip_velocity"])
                            self.turbulence_interaction = self.__class__.turbulence_interaction(service, version, mode, path + ["turbulence_interaction"])
                            self.turbulent_dispersion = self.__class__.turbulent_dispersion(service, version, mode, path + ["turbulent_dispersion"])
                            self.wall_lubrication = self.__class__.wall_lubrication(service, version, mode, path + ["wall_lubrication"])
                            super().__init__(service, version, mode, path)
                        class drag(TUIMethod):
                            """
                            Specify the drag function for each pair of phases. It also enables drag modification and allow specifying the drag factor.
                            """
                        class heat_coeff(TUIMethod):
                            """
                            Specify the heat transfer coefficient function between each pair of phases.
                            """
                        class interfacial_area(TUIMethod):
                            """
                            Set the interfacial area parameters for each pair of phases.
                            """
                        class mass_transfer(TUIMethod):
                            """
                            Specify the mass transfer mechanisms.
                            """
                        class model_transition(TUIMethod):
                            """
                            Set the model transition mechanism.
                            """
                        class reactions(TUIMethod):
                            """
                            Define multiple heterogeneous reactions and stoichiometry.
                            """
                        class restitution(TUIMethod):
                            """
                            Specify the restitution coefficient for collisions between each pair of granular phases and for collisions between particles of the same granular phase.
                            """
                        class slip_velocity(TUIMethod):
                            """
                            Specify the slip velocity function for each secondary phase with respect to the primary phase.
                            """
                        class turbulence_interaction(TUIMethod):
                            """
                            Specify the turbulence interaction model for each primary-secondary phase pair.
                            """
                        class turbulent_dispersion(TUIMethod):
                            """
                            Specify the turbulent dispersion model for each primary-secondary phase pair.
                            """
                        class wall_lubrication(TUIMethod):
                            """
                            Specify the wall lubrication model for each primary-secondary phase pair.
                            """

                        class cavitation(TUIMenu):
                            """
                            Enter the menu to set cavitation models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_discretization(TUIMenu):
                            """
                            Enter the menu to set interphase discretization models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_viscous_dissipation(TUIMenu):
                            """
                            Enter the menu to set interphase viscous dissipation related models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class lift(TUIMenu):
                            """
                            Enter the menu to set lift models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class surface_tension(TUIMenu):
                            """
                            Enter the menu to set surface tension models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class virtual_mass(TUIMenu):
                            """
                            Enter the menu to set virtual mass models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                    class model_transition(TUIMenu):
                        """
                        Enter the menu to set model transition mechanisms.
                        """
                        def __init__(self, service, version, mode, path):
                            self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                            self.interphase_discretization = self.__class__.interphase_discretization(service, version, mode, path + ["interphase_discretization"])
                            self.interphase_viscous_dissipation = self.__class__.interphase_viscous_dissipation(service, version, mode, path + ["interphase_viscous_dissipation"])
                            self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                            self.surface_tension = self.__class__.surface_tension(service, version, mode, path + ["surface_tension"])
                            self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                            self.drag = self.__class__.drag(service, version, mode, path + ["drag"])
                            self.heat_coeff = self.__class__.heat_coeff(service, version, mode, path + ["heat_coeff"])
                            self.interfacial_area = self.__class__.interfacial_area(service, version, mode, path + ["interfacial_area"])
                            self.mass_transfer = self.__class__.mass_transfer(service, version, mode, path + ["mass_transfer"])
                            self.model_transition = self.__class__.model_transition(service, version, mode, path + ["model_transition"])
                            self.reactions = self.__class__.reactions(service, version, mode, path + ["reactions"])
                            self.restitution = self.__class__.restitution(service, version, mode, path + ["restitution"])
                            self.slip_velocity = self.__class__.slip_velocity(service, version, mode, path + ["slip_velocity"])
                            self.turbulence_interaction = self.__class__.turbulence_interaction(service, version, mode, path + ["turbulence_interaction"])
                            self.turbulent_dispersion = self.__class__.turbulent_dispersion(service, version, mode, path + ["turbulent_dispersion"])
                            self.wall_lubrication = self.__class__.wall_lubrication(service, version, mode, path + ["wall_lubrication"])
                            super().__init__(service, version, mode, path)
                        class drag(TUIMethod):
                            """
                            Specify the drag function for each pair of phases. It also enables drag modification and allow specifying the drag factor.
                            """
                        class heat_coeff(TUIMethod):
                            """
                            Specify the heat transfer coefficient function between each pair of phases.
                            """
                        class interfacial_area(TUIMethod):
                            """
                            Set the interfacial area parameters for each pair of phases.
                            """
                        class mass_transfer(TUIMethod):
                            """
                            Specify the mass transfer mechanisms.
                            """
                        class model_transition(TUIMethod):
                            """
                            Set the model transition mechanism.
                            """
                        class reactions(TUIMethod):
                            """
                            Define multiple heterogeneous reactions and stoichiometry.
                            """
                        class restitution(TUIMethod):
                            """
                            Specify the restitution coefficient for collisions between each pair of granular phases and for collisions between particles of the same granular phase.
                            """
                        class slip_velocity(TUIMethod):
                            """
                            Specify the slip velocity function for each secondary phase with respect to the primary phase.
                            """
                        class turbulence_interaction(TUIMethod):
                            """
                            Specify the turbulence interaction model for each primary-secondary phase pair.
                            """
                        class turbulent_dispersion(TUIMethod):
                            """
                            Specify the turbulent dispersion model for each primary-secondary phase pair.
                            """
                        class wall_lubrication(TUIMethod):
                            """
                            Specify the wall lubrication model for each primary-secondary phase pair.
                            """

                        class cavitation(TUIMenu):
                            """
                            Enter the menu to set cavitation models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_discretization(TUIMenu):
                            """
                            Enter the menu to set interphase discretization models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_viscous_dissipation(TUIMenu):
                            """
                            Enter the menu to set interphase viscous dissipation related models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class lift(TUIMenu):
                            """
                            Enter the menu to set lift models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class surface_tension(TUIMenu):
                            """
                            Enter the menu to set surface tension models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class virtual_mass(TUIMenu):
                            """
                            Enter the menu to set virtual mass models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                    class numerics(TUIMenu):
                        """
                        Enter the menu to set numerics models.
                        """
                        def __init__(self, service, version, mode, path):
                            self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                            self.interphase_discretization = self.__class__.interphase_discretization(service, version, mode, path + ["interphase_discretization"])
                            self.interphase_viscous_dissipation = self.__class__.interphase_viscous_dissipation(service, version, mode, path + ["interphase_viscous_dissipation"])
                            self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                            self.surface_tension = self.__class__.surface_tension(service, version, mode, path + ["surface_tension"])
                            self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                            self.drag = self.__class__.drag(service, version, mode, path + ["drag"])
                            self.heat_coeff = self.__class__.heat_coeff(service, version, mode, path + ["heat_coeff"])
                            self.interfacial_area = self.__class__.interfacial_area(service, version, mode, path + ["interfacial_area"])
                            self.mass_transfer = self.__class__.mass_transfer(service, version, mode, path + ["mass_transfer"])
                            self.model_transition = self.__class__.model_transition(service, version, mode, path + ["model_transition"])
                            self.reactions = self.__class__.reactions(service, version, mode, path + ["reactions"])
                            self.restitution = self.__class__.restitution(service, version, mode, path + ["restitution"])
                            self.slip_velocity = self.__class__.slip_velocity(service, version, mode, path + ["slip_velocity"])
                            self.turbulence_interaction = self.__class__.turbulence_interaction(service, version, mode, path + ["turbulence_interaction"])
                            self.turbulent_dispersion = self.__class__.turbulent_dispersion(service, version, mode, path + ["turbulent_dispersion"])
                            self.wall_lubrication = self.__class__.wall_lubrication(service, version, mode, path + ["wall_lubrication"])
                            super().__init__(service, version, mode, path)
                        class drag(TUIMethod):
                            """
                            Specify the drag function for each pair of phases. It also enables drag modification and allow specifying the drag factor.
                            """
                        class heat_coeff(TUIMethod):
                            """
                            Specify the heat transfer coefficient function between each pair of phases.
                            """
                        class interfacial_area(TUIMethod):
                            """
                            Set the interfacial area parameters for each pair of phases.
                            """
                        class mass_transfer(TUIMethod):
                            """
                            Specify the mass transfer mechanisms.
                            """
                        class model_transition(TUIMethod):
                            """
                            Set the model transition mechanism.
                            """
                        class reactions(TUIMethod):
                            """
                            Define multiple heterogeneous reactions and stoichiometry.
                            """
                        class restitution(TUIMethod):
                            """
                            Specify the restitution coefficient for collisions between each pair of granular phases and for collisions between particles of the same granular phase.
                            """
                        class slip_velocity(TUIMethod):
                            """
                            Specify the slip velocity function for each secondary phase with respect to the primary phase.
                            """
                        class turbulence_interaction(TUIMethod):
                            """
                            Specify the turbulence interaction model for each primary-secondary phase pair.
                            """
                        class turbulent_dispersion(TUIMethod):
                            """
                            Specify the turbulent dispersion model for each primary-secondary phase pair.
                            """
                        class wall_lubrication(TUIMethod):
                            """
                            Specify the wall lubrication model for each primary-secondary phase pair.
                            """

                        class cavitation(TUIMenu):
                            """
                            Enter the menu to set cavitation models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_discretization(TUIMenu):
                            """
                            Enter the menu to set interphase discretization models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class interphase_viscous_dissipation(TUIMenu):
                            """
                            Enter the menu to set interphase viscous dissipation related models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class lift(TUIMenu):
                            """
                            Enter the menu to set lift models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class surface_tension(TUIMenu):
                            """
                            Enter the menu to set surface tension models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

                        class virtual_mass(TUIMenu):
                            """
                            Enter the menu to set virtual mass models.
                            """
                            def __init__(self, service, version, mode, path):
                                self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                                self.interphase_discr = self.__class__.interphase_discr(service, version, mode, path + ["interphase_discr"])
                                self.interphase_visc_disp = self.__class__.interphase_visc_disp(service, version, mode, path + ["interphase_visc_disp"])
                                self.jump_adhesion = self.__class__.jump_adhesion(service, version, mode, path + ["jump_adhesion"])
                                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                                self.lift_montoya = self.__class__.lift_montoya(service, version, mode, path + ["lift_montoya"])
                                self.lift_shaver_podowski = self.__class__.lift_shaver_podowski(service, version, mode, path + ["lift_shaver_podowski"])
                                self.sfc_model_type = self.__class__.sfc_model_type(service, version, mode, path + ["sfc_model_type"])
                                self.sfc_modeling = self.__class__.sfc_modeling(service, version, mode, path + ["sfc_modeling"])
                                self.sfc_tension_coeff = self.__class__.sfc_tension_coeff(service, version, mode, path + ["sfc_tension_coeff"])
                                self.slope_limiter = self.__class__.slope_limiter(service, version, mode, path + ["slope_limiter"])
                                self.virtual_mass = self.__class__.virtual_mass(service, version, mode, path + ["virtual_mass"])
                                self.visc_disp_factor = self.__class__.visc_disp_factor(service, version, mode, path + ["visc_disp_factor"])
                                self.vmass_coeff = self.__class__.vmass_coeff(service, version, mode, path + ["vmass_coeff"])
                                self.vmass_implicit = self.__class__.vmass_implicit(service, version, mode, path + ["vmass_implicit"])
                                self.vmass_implicit_options = self.__class__.vmass_implicit_options(service, version, mode, path + ["vmass_implicit_options"])
                                self.wall_adhesion = self.__class__.wall_adhesion(service, version, mode, path + ["wall_adhesion"])
                                super().__init__(service, version, mode, path)
                            class cavitation(TUIMethod):
                                """
                                Set the vaporization pressure, the surface tension coefficient, and the non-condensable gas mass fraction.
                                """
                            class interphase_discr(TUIMethod):
                                """
                                Enable the phase localized compressive discretization scheme where the degree of diffusion/sharpness is controlled through the value of the slope limiters?.
                                """
                            class interphase_visc_disp(TUIMethod):
                                """
                                Enable the interfacial viscous dissipation method, which introduces an artificial viscous damping term in the momentum equation?.
                                """
                            class jump_adhesion(TUIMethod):
                                """
                                Enable the treatment of the contact angle specification at the porous jump boundary?.
                                """
                            class lift(TUIMethod):
                                """
                                .
                                """
                            class lift_montoya(TUIMethod):
                                """
                                Include the Montoya correction for Lift.
                                """
                            class lift_shaver_podowski(TUIMethod):
                                """
                                Include the Shaver-Podowski correction for Lift.
                                """
                            class sfc_model_type(TUIMethod):
                                """
                                Select the surface tension model.
                                """
                            class sfc_modeling(TUIMethod):
                                """
                                Include the effects of surface tension along the fluid-fluid interface?.
                                """
                            class sfc_tension_coeff(TUIMethod):
                                """
                                Specify the surface tension coefficient for each pair of phases.
                                """
                            class slope_limiter(TUIMethod):
                                """
                                Specify the slope limiter to set a specific discretization scheme. 0: first order upwind, 1: second order reconstruction bounded by the global minimum/maximum of the volume fraction, 2: compressive. Value between 0 and 2: blended scheme.
                                """
                            class virtual_mass(TUIMethod):
                                """
                                Include the virtual mass force that is present when a secondary phase accelerates relative to the primary phase?.
                                """
                            class visc_disp_factor(TUIMethod):
                                """
                                Set the dissipation intensity.
                                """
                            class vmass_coeff(TUIMethod):
                                """
                                Specify the virtual mass coefficient for each pair of phases.
                                """
                            class vmass_implicit(TUIMethod):
                                """
                                Enable the implicit method for the virtual mass force?.
                                """
                            class vmass_implicit_options(TUIMethod):
                                """
                                Select the virtual mass implicit option.
                                """
                            class wall_adhesion(TUIMethod):
                                """
                                Enable the specification for a wall adhesion angle?.
                                """

        class profiles(TUIMenu):
            """
            Enter the boundary profiles menu.
            """
            def __init__(self, service, version, mode, path):
                self.circumferential_averaged_profile_enhanced_bands_check = self.__class__.circumferential_averaged_profile_enhanced_bands_check(service, version, mode, path + ["circumferential_averaged_profile_enhanced_bands_check"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                self.display_profile_point_cloud_data = self.__class__.display_profile_point_cloud_data(service, version, mode, path + ["display_profile_point_cloud_data"])
                self.display_profile_surface = self.__class__.display_profile_surface(service, version, mode, path + ["display_profile_surface"])
                self.interpolation_method = self.__class__.interpolation_method(service, version, mode, path + ["interpolation_method"])
                self.link_profile_to_reference_frame = self.__class__.link_profile_to_reference_frame(service, version, mode, path + ["link_profile_to_reference_frame"])
                self.list_profile_fields = self.__class__.list_profile_fields(service, version, mode, path + ["list_profile_fields"])
                self.list_profile_parameters = self.__class__.list_profile_parameters(service, version, mode, path + ["list_profile_parameters"])
                self.list_profile_parameters_with_value = self.__class__.list_profile_parameters_with_value(service, version, mode, path + ["list_profile_parameters_with_value"])
                self.list_profiles = self.__class__.list_profiles(service, version, mode, path + ["list_profiles"])
                self.morphing = self.__class__.morphing(service, version, mode, path + ["morphing"])
                self.orient_profile = self.__class__.orient_profile(service, version, mode, path + ["orient_profile"])
                self.overlay_profile_point_cloud_data = self.__class__.overlay_profile_point_cloud_data(service, version, mode, path + ["overlay_profile_point_cloud_data"])
                self.overlay_profile_surface = self.__class__.overlay_profile_surface(service, version, mode, path + ["overlay_profile_surface"])
                self.replicate_profile = self.__class__.replicate_profile(service, version, mode, path + ["replicate_profile"])
                self.set_preference_profile_point_cloud_data = self.__class__.set_preference_profile_point_cloud_data(service, version, mode, path + ["set_preference_profile_point_cloud_data"])
                self.update_interval = self.__class__.update_interval(service, version, mode, path + ["update_interval"])
                super().__init__(service, version, mode, path)
            class circumferential_averaged_profile_enhanced_bands_check(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class delete_all(TUIMethod):
                """
                .
                """
            class display_profile_point_cloud_data(TUIMethod):
                """
                .
                """
            class display_profile_surface(TUIMethod):
                """
                .
                """
            class interpolation_method(TUIMethod):
                """
                Choose the method for interpolation of profiles.
                """
            class link_profile_to_reference_frame(TUIMethod):
                """
                Link profile to a reference frame.
                """
            class list_profile_fields(TUIMethod):
                """
                .
                """
            class list_profile_parameters(TUIMethod):
                """
                .
                """
            class list_profile_parameters_with_value(TUIMethod):
                """
                .
                """
            class list_profiles(TUIMethod):
                """
                .
                """
            class morphing(TUIMethod):
                """
                Enable/disable profile morphing options in Orient Profile panel.
                """
            class orient_profile(TUIMethod):
                """
                Orient Profile.
                """
            class overlay_profile_point_cloud_data(TUIMethod):
                """
                .
                """
            class overlay_profile_surface(TUIMethod):
                """
                .
                """
            class replicate_profile(TUIMethod):
                """
                Replicate Profile.
                """
            class set_preference_profile_point_cloud_data(TUIMethod):
                """
                .
                """
            class update_interval(TUIMethod):
                """
                .
                """

        class reference_frames(TUIMenu):
            """
            Manage reference frames.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.display_edit = self.__class__.display_edit(service, version, mode, path + ["display_edit"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.hide = self.__class__.hide(service, version, mode, path + ["hide"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class display(TUIMethod):
                """
                Display Reference Frame.
                """
            class display_edit(TUIMethod):
                """
                Display and edit reference frame from graphics.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class hide(TUIMethod):
                """
                Hide Reference Frame.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """

        class solution_strategy(TUIMenu):
            """
            Enter the automatic initialization and case modification strategy menu.
            """
            def __init__(self, service, version, mode, path):
                self.automatic_case_modification = self.__class__.automatic_case_modification(service, version, mode, path + ["automatic_case_modification"])
                self.add_edit_modification = self.__class__.add_edit_modification(service, version, mode, path + ["add_edit_modification"])
                self.automatic_initialization = self.__class__.automatic_initialization(service, version, mode, path + ["automatic_initialization"])
                self.continue_strategy_execution = self.__class__.continue_strategy_execution(service, version, mode, path + ["continue_strategy_execution"])
                self.copy_modification = self.__class__.copy_modification(service, version, mode, path + ["copy_modification"])
                self.delete_modification = self.__class__.delete_modification(service, version, mode, path + ["delete_modification"])
                self.disable_modification = self.__class__.disable_modification(service, version, mode, path + ["disable_modification"])
                self.enable_modification = self.__class__.enable_modification(service, version, mode, path + ["enable_modification"])
                self.enable_strategy = self.__class__.enable_strategy(service, version, mode, path + ["enable_strategy"])
                self.execute_strategy = self.__class__.execute_strategy(service, version, mode, path + ["execute_strategy"])
                self.export_modifications = self.__class__.export_modifications(service, version, mode, path + ["export_modifications"])
                self.import_modifications = self.__class__.import_modifications(service, version, mode, path + ["import_modifications"])
                super().__init__(service, version, mode, path)
            class add_edit_modification(TUIMethod):
                """
                .
                """
            class automatic_initialization(TUIMethod):
                """
                .
                """
            class continue_strategy_execution(TUIMethod):
                """
                .
                """
            class copy_modification(TUIMethod):
                """
                .
                """
            class delete_modification(TUIMethod):
                """
                .
                """
            class disable_modification(TUIMethod):
                """
                .
                """
            class enable_modification(TUIMethod):
                """
                .
                """
            class enable_strategy(TUIMethod):
                """
                .
                """
            class execute_strategy(TUIMethod):
                """
                .
                """
            class export_modifications(TUIMethod):
                """
                .
                """
            class import_modifications(TUIMethod):
                """
                .
                """

            class automatic_case_modification(TUIMenu):
                """
                Define how the case is to be modified as the solution progresses.
                """
                def __init__(self, service, version, mode, path):
                    self.before_init_modification = self.__class__.before_init_modification(service, version, mode, path + ["before_init_modification"])
                    self.modifications = self.__class__.modifications(service, version, mode, path + ["modifications"])
                    self.original_settings = self.__class__.original_settings(service, version, mode, path + ["original_settings"])
                    super().__init__(service, version, mode, path)
                class before_init_modification(TUIMethod):
                    """
                    Specify modification to be performed before initialization.
                    """
                class modifications(TUIMethod):
                    """
                    Specify modifications to be performed during solution.
                    """
                class original_settings(TUIMethod):
                    """
                    Specify modification to be performed after initialization to restore to original settings.
                    """

        class spectral(TUIMenu):
            """
            Enter the Spectral menu.
            """
            def __init__(self, service, version, mode, path):
                self.calculate_fourier_coefficients = self.__class__.calculate_fourier_coefficients(service, version, mode, path + ["calculate_fourier_coefficients"])
                self.calculate_harmonic_exports = self.__class__.calculate_harmonic_exports(service, version, mode, path + ["calculate_harmonic_exports"])
                self.delete_fourier_coefficients = self.__class__.delete_fourier_coefficients(service, version, mode, path + ["delete_fourier_coefficients"])
                self.delete_harmonic_exports = self.__class__.delete_harmonic_exports(service, version, mode, path + ["delete_harmonic_exports"])
                super().__init__(service, version, mode, path)
            class calculate_fourier_coefficients(TUIMethod):
                """
                Calculates Fourier coefficient data.
                """
            class calculate_harmonic_exports(TUIMethod):
                """
                Calculates Harmonic Export data.
                """
            class delete_fourier_coefficients(TUIMethod):
                """
                Deletes Fourier coefficient data.
                """
            class delete_harmonic_exports(TUIMethod):
                """
                Deletes Harmonic Export data.
                """

        class turbo_model(TUIMenu):
            """
            Turbo features menu.
            """
            def __init__(self, service, version, mode, path):
                self.blade_flutter_harmonics = self.__class__.blade_flutter_harmonics(service, version, mode, path + ["blade_flutter_harmonics"])
                self.general_turbo_interface_settings = self.__class__.general_turbo_interface_settings(service, version, mode, path + ["general_turbo_interface_settings"])
                self.legacy_models = self.__class__.legacy_models(service, version, mode, path + ["legacy_models"])
                self.turbo_topology = self.__class__.turbo_topology(service, version, mode, path + ["turbo_topology"])
                self.append_graphics_spectral_content = self.__class__.append_graphics_spectral_content(service, version, mode, path + ["append_graphics_spectral_content"])
                self.append_phaselag_spectral_content = self.__class__.append_phaselag_spectral_content(service, version, mode, path + ["append_phaselag_spectral_content"])
                self.blade_flutter_row = self.__class__.blade_flutter_row(service, version, mode, path + ["blade_flutter_row"])
                self.create_graphics_spectral_content = self.__class__.create_graphics_spectral_content(service, version, mode, path + ["create_graphics_spectral_content"])
                self.create_phaselag_spectral_content = self.__class__.create_phaselag_spectral_content(service, version, mode, path + ["create_phaselag_spectral_content"])
                self.create_turbomachine_description = self.__class__.create_turbomachine_description(service, version, mode, path + ["create_turbomachine_description"])
                self.delete_graphics_spectral_content = self.__class__.delete_graphics_spectral_content(service, version, mode, path + ["delete_graphics_spectral_content"])
                self.delete_phaselag_spectral_content = self.__class__.delete_phaselag_spectral_content(service, version, mode, path + ["delete_phaselag_spectral_content"])
                self.delete_turbomachine_description = self.__class__.delete_turbomachine_description(service, version, mode, path + ["delete_turbomachine_description"])
                self.enable_turbo_model = self.__class__.enable_turbo_model(service, version, mode, path + ["enable_turbo_model"])
                self.export_boundary_mesh = self.__class__.export_boundary_mesh(service, version, mode, path + ["export_boundary_mesh"])
                self.graphics_extra_settings = self.__class__.graphics_extra_settings(service, version, mode, path + ["graphics_extra_settings"])
                self.list_graphics_spectral_content = self.__class__.list_graphics_spectral_content(service, version, mode, path + ["list_graphics_spectral_content"])
                self.list_phaselag_state = self.__class__.list_phaselag_state(service, version, mode, path + ["list_phaselag_state"])
                self.list_turbomachine_description = self.__class__.list_turbomachine_description(service, version, mode, path + ["list_turbomachine_description"])
                self.make_phaselag_from_boundaries = self.__class__.make_phaselag_from_boundaries(service, version, mode, path + ["make_phaselag_from_boundaries"])
                self.make_phaselag_from_periodic = self.__class__.make_phaselag_from_periodic(service, version, mode, path + ["make_phaselag_from_periodic"])
                self.performance = self.__class__.performance(service, version, mode, path + ["performance"])
                self.phaselag_extra_settings = self.__class__.phaselag_extra_settings(service, version, mode, path + ["phaselag_extra_settings"])
                self.separate_nonoverlapping_interface_boundary = self.__class__.separate_nonoverlapping_interface_boundary(service, version, mode, path + ["separate_nonoverlapping_interface_boundary"])
                self.turbo_create = self.__class__.turbo_create(service, version, mode, path + ["turbo_create"])
                self.turbo_interface_check = self.__class__.turbo_interface_check(service, version, mode, path + ["turbo_interface_check"])
                self.turbo_interface_delete = self.__class__.turbo_interface_delete(service, version, mode, path + ["turbo_interface_delete"])
                self.turbo_interface_edit = self.__class__.turbo_interface_edit(service, version, mode, path + ["turbo_interface_edit"])
                super().__init__(service, version, mode, path)
            class append_graphics_spectral_content(TUIMethod):
                """
                Define post-processing related spectral content.
                """
            class append_phaselag_spectral_content(TUIMethod):
                """
                Define phaselag related spectral content.
                """
            class blade_flutter_row(TUIMethod):
                """
                Define the periodic displacement row.
                """
            class create_graphics_spectral_content(TUIMethod):
                """
                Define post-processing related spectral content.
                """
            class create_phaselag_spectral_content(TUIMethod):
                """
                Define phaselag related spectral content.
                """
            class create_turbomachine_description(TUIMethod):
                """
                Define turbomachine description.
                """
            class delete_graphics_spectral_content(TUIMethod):
                """
                Delete post-processing related spectral content.
                """
            class delete_phaselag_spectral_content(TUIMethod):
                """
                Delete phaselag related spectral content.
                """
            class delete_turbomachine_description(TUIMethod):
                """
                Delete turbomachine description.
                """
            class enable_turbo_model(TUIMethod):
                """
                .
                """
            class export_boundary_mesh(TUIMethod):
                """
                .
                """
            class graphics_extra_settings(TUIMethod):
                """
                Define phaselag related extra settings.
                """
            class list_graphics_spectral_content(TUIMethod):
                """
                List post-processing related spectral content.
                """
            class list_phaselag_state(TUIMethod):
                """
                List all phaselag related case settings.
                """
            class list_turbomachine_description(TUIMethod):
                """
                List turbomachine description.
                """
            class make_phaselag_from_boundaries(TUIMethod):
                """
                Make interface zones phase lagged.
                """
            class make_phaselag_from_periodic(TUIMethod):
                """
                Convert periodic interface to phase lagged.
                """
            class performance(TUIMethod):
                """
                Define expressions to evaluate turbomachine performance.
                """
            class phaselag_extra_settings(TUIMethod):
                """
                Define phaselag related extra settings.
                """
            class separate_nonoverlapping_interface_boundary(TUIMethod):
                """
                Split a general turbo interface non-overlapping zone.
                """
            class turbo_create(TUIMethod):
                """
                .
                """
            class turbo_interface_check(TUIMethod):
                """
                .
                """
            class turbo_interface_delete(TUIMethod):
                """
                .
                """
            class turbo_interface_edit(TUIMethod):
                """
                Edit a general turbo and standard tip-gap interface.
                """

            class blade_flutter_harmonics(TUIMenu):
                """
                Enter the blade flutter harmonics menu.
                """
                def __init__(self, service, version, mode, path):
                    self.enable_harmonic_exports = self.__class__.enable_harmonic_exports(service, version, mode, path + ["enable_harmonic_exports"])
                    self.write_aerodamping_vs_nodal_diameter = self.__class__.write_aerodamping_vs_nodal_diameter(service, version, mode, path + ["write_aerodamping_vs_nodal_diameter"])
                    self.write_harmonic_exports = self.__class__.write_harmonic_exports(service, version, mode, path + ["write_harmonic_exports"])
                    super().__init__(service, version, mode, path)
                class enable_harmonic_exports(TUIMethod):
                    """
                    Calculates/Deletes flutter harmonic export data.
                    """
                class write_aerodamping_vs_nodal_diameter(TUIMethod):
                    """
                    Reads report definition file and Writes influence coefficient aerodynamic damping values vs nodal diameter.
                    """
                class write_harmonic_exports(TUIMethod):
                    """
                    Writes harmonic export data.
                    """

            class general_turbo_interface_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.mixing_plane_model_settings = self.__class__.mixing_plane_model_settings(service, version, mode, path + ["mixing_plane_model_settings"])
                    super().__init__(service, version, mode, path)

                class expert(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.backward_compatibility = self.__class__.backward_compatibility(service, version, mode, path + ["backward_compatibility"])
                        self.enforce_flux_scaling = self.__class__.enforce_flux_scaling(service, version, mode, path + ["enforce_flux_scaling"])
                        self.enhanced_mpm_bands_viability_check = self.__class__.enhanced_mpm_bands_viability_check(service, version, mode, path + ["enhanced_mpm_bands_viability_check"])
                        self.list_settings = self.__class__.list_settings(service, version, mode, path + ["list_settings"])
                        self.nps_minimize_po_loss = self.__class__.nps_minimize_po_loss(service, version, mode, path + ["nps_minimize_po_loss"])
                        super().__init__(service, version, mode, path)
                    class enforce_flux_scaling(TUIMethod):
                        """
                        .
                        """
                    class enhanced_mpm_bands_viability_check(TUIMethod):
                        """
                        .
                        """
                    class list_settings(TUIMethod):
                        """
                        .
                        """
                    class nps_minimize_po_loss(TUIMethod):
                        """
                        .
                        """

                    class backward_compatibility(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.pre_24r2_mp_discretization = self.__class__.pre_24r2_mp_discretization(service, version, mode, path + ["pre_24r2_mp_discretization"])
                            super().__init__(service, version, mode, path)
                        class pre_24r2_mp_discretization(TUIMethod):
                            """
                            .
                            """

                class mixing_plane_model_settings(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.number_of_bands = self.__class__.number_of_bands(service, version, mode, path + ["number_of_bands"])
                        self.bands_type = self.__class__.bands_type(service, version, mode, path + ["bands_type"])
                        self.list_mixing_planes = self.__class__.list_mixing_planes(service, version, mode, path + ["list_mixing_planes"])
                        super().__init__(service, version, mode, path)
                    class bands_type(TUIMethod):
                        """
                        .
                        """
                    class list_mixing_planes(TUIMethod):
                        """
                        .
                        """

                    class number_of_bands(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.set_all_interfaces = self.__class__.set_all_interfaces(service, version, mode, path + ["set_all_interfaces"])
                            self.set_specific_interface = self.__class__.set_specific_interface(service, version, mode, path + ["set_specific_interface"])
                            super().__init__(service, version, mode, path)
                        class set_all_interfaces(TUIMethod):
                            """
                            .
                            """
                        class set_specific_interface(TUIMethod):
                            """
                            .
                            """

            class legacy_models(TUIMenu):
                """
                Enter Legacy Turbo Model Menu.
                """
                def __init__(self, service, version, mode, path):
                    self.legacy_mixing_plane = self.__class__.legacy_mixing_plane(service, version, mode, path + ["legacy_mixing_plane"])
                    super().__init__(service, version, mode, path)

                class legacy_mixing_plane(TUIMenu):
                    """
                    Enter the legacy mixing planes menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.set = self.__class__.set(service, version, mode, path + ["set"])
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.mixing_plane_gui = self.__class__.mixing_plane_gui(service, version, mode, path + ["mixing_plane_gui"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        Create a mixing plane.
                        """
                    class delete(TUIMethod):
                        """
                        Delete a mixing plane.
                        """
                    class list(TUIMethod):
                        """
                        List defined mixing plane(s).
                        """
                    class mixing_plane_gui(TUIMethod):
                        """
                        GUI for setting up legacy mixing plane model.
                        """

                    class set(TUIMenu):
                        """
                        Enter the mixing plane set menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.conserve_swirl = self.__class__.conserve_swirl(service, version, mode, path + ["conserve_swirl"])
                            self.conserve_total_enthalpy = self.__class__.conserve_total_enthalpy(service, version, mode, path + ["conserve_total_enthalpy"])
                            self.averaging_method = self.__class__.averaging_method(service, version, mode, path + ["averaging_method"])
                            self.fix_pressure_level = self.__class__.fix_pressure_level(service, version, mode, path + ["fix_pressure_level"])
                            self.under_relaxation = self.__class__.under_relaxation(service, version, mode, path + ["under_relaxation"])
                            super().__init__(service, version, mode, path)
                        class averaging_method(TUIMethod):
                            """
                            Set mixing plane profile averaging method.
                            """
                        class fix_pressure_level(TUIMethod):
                            """
                            Set fix pressure level using define/reference-pressure-location.
                            """
                        class under_relaxation(TUIMethod):
                            """
                            Set mixing plane under-relaxation factor.
                            """

                        class conserve_swirl(TUIMenu):
                            """
                            Enter the mixing plane conserve-swirl menu.
                            """
                            def __init__(self, service, version, mode, path):
                                self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                                self.report_swirl_integration = self.__class__.report_swirl_integration(service, version, mode, path + ["report_swirl_integration"])
                                self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                                super().__init__(service, version, mode, path)
                            class enable(TUIMethod):
                                """
                                Enable/disable swirl conservation in mixing plane.
                                """
                            class report_swirl_integration(TUIMethod):
                                """
                                Report swirl integration (torque) on inflow and outflow zones.
                                """
                            class verbosity(TUIMethod):
                                """
                                Enable/disable verbosity in swirl conservation calculations.
                                """

                        class conserve_total_enthalpy(TUIMenu):
                            """
                            Enter the menu to set total enthalpy conservation in mixing plane menu.
                            """
                            def __init__(self, service, version, mode, path):
                                self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                                self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                                super().__init__(service, version, mode, path)
                            class enable(TUIMethod):
                                """
                                Enable/disable total enthalpy conservation in mixing plane.
                                """
                            class verbosity(TUIMethod):
                                """
                                Enable/disable verbosity in total-enthalpy conservation calculations.
                                """

            class turbo_topology(TUIMenu):
                """
                Define turbo topology.
                """
                def __init__(self, service, version, mode, path):
                    self.define_topology = self.__class__.define_topology(service, version, mode, path + ["define_topology"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.mesh_method = self.__class__.mesh_method(service, version, mode, path + ["mesh_method"])
                    self.projection_method = self.__class__.projection_method(service, version, mode, path + ["projection_method"])
                    self.search_method = self.__class__.search_method(service, version, mode, path + ["search_method"])
                    super().__init__(service, version, mode, path)
                class define_topology(TUIMethod):
                    """
                    Define a turbo topology.
                    """
                class delete(TUIMethod):
                    """
                    Delete a turbo topology.
                    """
                class mesh_method(TUIMethod):
                    """
                    Set turbo structured mesh generation method.
                    """
                class projection_method(TUIMethod):
                    """
                    Set 2D projection method.
                    """
                class search_method(TUIMethod):
                    """
                    Set search method for a topology.
                    """

        class user_defined(TUIMenu):
            """
            Enter the user-defined functions and scalars menu.
            """
            def __init__(self, service, version, mode, path):
                self.real_gas_models = self.__class__.real_gas_models(service, version, mode, path + ["real_gas_models"])
                self.auto_compile_compiled_udfs = self.__class__.auto_compile_compiled_udfs(service, version, mode, path + ["auto_compile_compiled_udfs"])
                self.compile_customized_addon_module = self.__class__.compile_customized_addon_module(service, version, mode, path + ["compile_customized_addon_module"])
                self.compiled_functions = self.__class__.compiled_functions(service, version, mode, path + ["compiled_functions"])
                self.enable_udf_on_gpu = self.__class__.enable_udf_on_gpu(service, version, mode, path + ["enable_udf_on_gpu"])
                self.execute_on_demand = self.__class__.execute_on_demand(service, version, mode, path + ["execute_on_demand"])
                self.fan_model = self.__class__.fan_model(service, version, mode, path + ["fan_model"])
                self.function_hooks = self.__class__.function_hooks(service, version, mode, path + ["function_hooks"])
                self.interpreted_functions = self.__class__.interpreted_functions(service, version, mode, path + ["interpreted_functions"])
                self.one_D_coupling = self.__class__.one_D_coupling(service, version, mode, path + ["one_D_coupling"])
                self.use_built_in_compiler = self.__class__.use_built_in_compiler(service, version, mode, path + ["use_built_in_compiler"])
                self.use_contributed_cpp = self.__class__.use_contributed_cpp(service, version, mode, path + ["use_contributed_cpp"])
                self.use_zone_based_udm = self.__class__.use_zone_based_udm(service, version, mode, path + ["use_zone_based_udm"])
                self.user_defined_memory = self.__class__.user_defined_memory(service, version, mode, path + ["user_defined_memory"])
                self.user_defined_node_memory = self.__class__.user_defined_node_memory(service, version, mode, path + ["user_defined_node_memory"])
                self.user_defined_scalars = self.__class__.user_defined_scalars(service, version, mode, path + ["user_defined_scalars"])
                super().__init__(service, version, mode, path)
            class auto_compile_compiled_udfs(TUIMethod):
                """
                .
                """
            class compile_customized_addon_module(TUIMethod):
                """
                Compile customized addon module?.
                """
            class compiled_functions(TUIMethod):
                """
                Open user-defined function library. test.
                """
            class enable_udf_on_gpu(TUIMethod):
                """
                .
                """
            class execute_on_demand(TUIMethod):
                """
                .
                """
            class fan_model(TUIMethod):
                """
                .
                """
            class function_hooks(TUIMethod):
                """
                Hook up user-defined functions.
                """
            class interpreted_functions(TUIMethod):
                """
                Load interpreted user-defined functions.
                """
            class one_D_coupling(TUIMethod):
                """
                .
                """
            class use_built_in_compiler(TUIMethod):
                """
                Enable/disable the use of the built-in compiler.
                """
            class use_contributed_cpp(TUIMethod):
                """
                .
                """
            class use_zone_based_udm(TUIMethod):
                """
                .
                """
            class user_defined_memory(TUIMethod):
                """
                Allocate user-defined memory.
                """
            class user_defined_node_memory(TUIMethod):
                """
                .
                """
            class user_defined_scalars(TUIMethod):
                """
                Define user-defined scalars.
                """

            class real_gas_models(TUIMenu):
                """
                Enable/configure real gas model.
                """
                def __init__(self, service, version, mode, path):
                    self.nist_multispecies_real_gas_model = self.__class__.nist_multispecies_real_gas_model(service, version, mode, path + ["nist_multispecies_real_gas_model"])
                    self.nist_real_gas_model = self.__class__.nist_real_gas_model(service, version, mode, path + ["nist_real_gas_model"])
                    self.nist_settings = self.__class__.nist_settings(service, version, mode, path + ["nist_settings"])
                    self.set_state = self.__class__.set_state(service, version, mode, path + ["set_state"])
                    self.user_defined_multispecies_real_gas_model = self.__class__.user_defined_multispecies_real_gas_model(service, version, mode, path + ["user_defined_multispecies_real_gas_model"])
                    self.user_defined_real_gas_model = self.__class__.user_defined_real_gas_model(service, version, mode, path + ["user_defined_real_gas_model"])
                    super().__init__(service, version, mode, path)
                class nist_multispecies_real_gas_model(TUIMethod):
                    """
                    Load NIST real gas library.
                    """
                class nist_real_gas_model(TUIMethod):
                    """
                    Load NIST real gas library.
                    """
                class nist_settings(TUIMethod):
                    """
                    Select refprop library.
                    """
                class set_state(TUIMethod):
                    """
                    Select state for NIST real gas model.
                    """
                class user_defined_multispecies_real_gas_model(TUIMethod):
                    """
                    Load user-defined multispecies real gas library.
                    """
                class user_defined_real_gas_model(TUIMethod):
                    """
                    Load user-defined real gas library.
                    """

        class virtual_boundary(TUIMenu):
            """
            Manage Virtual Boundaries.
            """
            def __init__(self, service, version, mode, path):
                self.boundary_interface = self.__class__.boundary_interface(service, version, mode, path + ["boundary_interface"])
                self.hole_geometry = self.__class__.hole_geometry(service, version, mode, path + ["hole_geometry"])
                super().__init__(service, version, mode, path)
            class boundary_interface(TUIMethod):
                """
                Create a Boundary Interface.
                """
            class hole_geometry(TUIMethod):
                """
                Create a Hole Geometry template.
                """

    class display(TUIMenu):
        """
        Enter the display menu.
        """
        def __init__(self, service, version, mode, path):
            self.define = self.__class__.define(service, version, mode, path + ["define"])
            self.display = self.__class__.display(service, version, mode, path + ["display"])
            self.display_states = self.__class__.display_states(service, version, mode, path + ["display_states"])
            self.embedded_windows = self.__class__.embedded_windows(service, version, mode, path + ["embedded_windows"])
            self.flamelet_data = self.__class__.flamelet_data(service, version, mode, path + ["flamelet_data"])
            self.objects = self.__class__.objects(service, version, mode, path + ["objects"])
            self.particle_tracks = self.__class__.particle_tracks(service, version, mode, path + ["particle_tracks"])
            self.path_lines = self.__class__.path_lines(service, version, mode, path + ["path_lines"])
            self.pdf_data = self.__class__.pdf_data(service, version, mode, path + ["pdf_data"])
            self.raytracer = self.__class__.raytracer(service, version, mode, path + ["raytracer"])
            self.set = self.__class__.set(service, version, mode, path + ["set"])
            self.surface = self.__class__.surface(service, version, mode, path + ["surface"])
            self.update_scene = self.__class__.update_scene(service, version, mode, path + ["update_scene"])
            self.view_sync = self.__class__.view_sync(service, version, mode, path + ["view_sync"])
            self.views = self.__class__.views(service, version, mode, path + ["views"])
            self.add_custom_vector = self.__class__.add_custom_vector(service, version, mode, path + ["add_custom_vector"])
            self.annotate = self.__class__.annotate(service, version, mode, path + ["annotate"])
            self.clear_annotations = self.__class__.clear_annotations(service, version, mode, path + ["clear_annotations"])
            self.close_window = self.__class__.close_window(service, version, mode, path + ["close_window"])
            self.close_window_by_name = self.__class__.close_window_by_name(service, version, mode, path + ["close_window_by_name"])
            self.contour = self.__class__.contour(service, version, mode, path + ["contour"])
            self.display_custom_vector = self.__class__.display_custom_vector(service, version, mode, path + ["display_custom_vector"])
            self.graphics_window_layout = self.__class__.graphics_window_layout(service, version, mode, path + ["graphics_window_layout"])
            self.grid = self.__class__.grid(service, version, mode, path + ["grid"])
            self.grid_outline = self.__class__.grid_outline(service, version, mode, path + ["grid_outline"])
            self.hsf_file = self.__class__.hsf_file(service, version, mode, path + ["hsf_file"])
            self.mesh = self.__class__.mesh(service, version, mode, path + ["mesh"])
            self.mesh_outline = self.__class__.mesh_outline(service, version, mode, path + ["mesh_outline"])
            self.mesh_partition_boundary = self.__class__.mesh_partition_boundary(service, version, mode, path + ["mesh_partition_boundary"])
            self.multigrid_coarsening = self.__class__.multigrid_coarsening(service, version, mode, path + ["multigrid_coarsening"])
            self.open_window = self.__class__.open_window(service, version, mode, path + ["open_window"])
            self.profile = self.__class__.profile(service, version, mode, path + ["profile"])
            self.re_render = self.__class__.re_render(service, version, mode, path + ["re_render"])
            self.re_scale = self.__class__.re_scale(service, version, mode, path + ["re_scale"])
            self.reacting_channel_curves = self.__class__.reacting_channel_curves(service, version, mode, path + ["reacting_channel_curves"])
            self.save_picture = self.__class__.save_picture(service, version, mode, path + ["save_picture"])
            self.set_list_tree_separator = self.__class__.set_list_tree_separator(service, version, mode, path + ["set_list_tree_separator"])
            self.set_window = self.__class__.set_window(service, version, mode, path + ["set_window"])
            self.set_window_by_name = self.__class__.set_window_by_name(service, version, mode, path + ["set_window_by_name"])
            self.surface_cells = self.__class__.surface_cells(service, version, mode, path + ["surface_cells"])
            self.surface_mesh = self.__class__.surface_mesh(service, version, mode, path + ["surface_mesh"])
            self.switch_to_post_processing_volume = self.__class__.switch_to_post_processing_volume(service, version, mode, path + ["switch_to_post_processing_volume"])
            self.switch_to_primary_volume = self.__class__.switch_to_primary_volume(service, version, mode, path + ["switch_to_primary_volume"])
            self.update_layout = self.__class__.update_layout(service, version, mode, path + ["update_layout"])
            self.vector = self.__class__.vector(service, version, mode, path + ["vector"])
            self.velocity_vector = self.__class__.velocity_vector(service, version, mode, path + ["velocity_vector"])
            self.zone_mesh = self.__class__.zone_mesh(service, version, mode, path + ["zone_mesh"])
            super().__init__(service, version, mode, path)
        class add_custom_vector(TUIMethod):
            """
            Add new custom vector definition.
            """
        class annotate(TUIMethod):
            """
            Add a text annotation string to the active graphics window.
            """
        class clear_annotations(TUIMethod):
            """
            Delete all annotation text.
            """
        class close_window(TUIMethod):
            """
            .
            """
        class close_window_by_name(TUIMethod):
            """
            .
            """
        class contour(TUIMethod):
            """
            Display contours of a flow variable.
            """
        class display_custom_vector(TUIMethod):
            """
            Display custom vector.
            """
        class graphics_window_layout(TUIMethod):
            """
            Arrange the graphics window layout.
            """
        class grid(TUIMethod):
            """
            Display the mesh.
            """
        class grid_outline(TUIMethod):
            """
            Display the mesh boundaries.
            """
        class hsf_file(TUIMethod):
            """
            Display hoops stream file data to active graphics window.
            """
        class mesh(TUIMethod):
            """
            Display the mesh.
            """
        class mesh_outline(TUIMethod):
            """
            Display the mesh boundaries.
            """
        class mesh_partition_boundary(TUIMethod):
            """
            Display mesh partition boundaries.
            """
        class multigrid_coarsening(TUIMethod):
            """
            Display a coarse mesh level from the last multigrid coarsening.
            """
        class open_window(TUIMethod):
            """
            .
            """
        class profile(TUIMethod):
            """
            Display profiles of a flow variable.
            """
        class re_render(TUIMethod):
            """
            Re-render the last contour, profile, or velocity vector plot
            with updated surfaces, meshes, lights, colormap, rendering options, etc.,
            without recalculating the contour data.
            """
        class re_scale(TUIMethod):
            """
            Re-render the last contour, profile, or velocity vector plot
            with updated scale, surfaces, meshes, lights, colormap, rendering options, etc.,
            without recalculating the field data.
            """
        class reacting_channel_curves(TUIMethod):
            """
            Plot/Report the reacting channel variables.
            """
        class save_picture(TUIMethod):
            """
            .
            """
        class set_list_tree_separator(TUIMethod):
            """
            Set the separator character for list tree.
            """
        class set_window(TUIMethod):
            """
            .
            """
        class set_window_by_name(TUIMethod):
            """
            .
            """
        class surface_cells(TUIMethod):
            """
            Draw the cells on the specified surfaces.
            """
        class surface_mesh(TUIMethod):
            """
            .
            """
        class switch_to_post_processing_volume(TUIMethod):
            """
            Switch to post processing volume.
            """
        class switch_to_primary_volume(TUIMethod):
            """
            Switch to primary volume.
            """
        class update_layout(TUIMethod):
            """
            Update the fluent layout.
            """
        class vector(TUIMethod):
            """
            Display space vectors.
            """
        class velocity_vector(TUIMethod):
            """
            Display velocity vectors.
            """
        class zone_mesh(TUIMethod):
            """
            .
            """

        class define(TUIMenu):
            """
            Enter Display define menu.
            """
            def __init__(self, service, version, mode, path):
                self.material = self.__class__.material(service, version, mode, path + ["material"])
                super().__init__(service, version, mode, path)

            class material(TUIMenu):
                """
                Add, Edit, Remove materials in case file.
                """
                def __init__(self, service, version, mode, path):
                    self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.new = self.__class__.new(service, version, mode, path + ["new"])
                    super().__init__(service, version, mode, path)
                class copy(TUIMethod):
                    """
                    Copy to new material.
                    """
                class delete(TUIMethod):
                    """
                    Remove  material.
                    """
                class edit(TUIMethod):
                    """
                    Edit material.
                    """
                class new(TUIMethod):
                    """
                    Create new material.
                    """

        class display(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.surface_mesh = self.__class__.surface_mesh(service, version, mode, path + ["surface_mesh"])
                self.zone_mesh = self.__class__.zone_mesh(service, version, mode, path + ["zone_mesh"])
                super().__init__(service, version, mode, path)
            class surface_mesh(TUIMethod):
                """
                .
                """
            class zone_mesh(TUIMethod):
                """
                .
                """

        class display_states(TUIMenu):
            """
            Enter the display state manipulation menu.
            """
            def __init__(self, service, version, mode, path):
                self.apply = self.__class__.apply(service, version, mode, path + ["apply"])
                self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.read = self.__class__.read(service, version, mode, path + ["read"])
                self.use_active = self.__class__.use_active(service, version, mode, path + ["use_active"])
                self.write = self.__class__.write(service, version, mode, path + ["write"])
                super().__init__(service, version, mode, path)
            class apply(TUIMethod):
                """
                Apply a display state to the active window.
                """
            class copy(TUIMethod):
                """
                Create a new display state with settings copied from an existing display state.
                """
            class create(TUIMethod):
                """
                Create a new display state.
                """
            class delete(TUIMethod):
                """
                Delete a display state.
                """
            class edit(TUIMethod):
                """
                Edit a particular display state setting.
                """
            class list(TUIMethod):
                """
                Print the names of the available display states to the console.
                """
            class read(TUIMethod):
                """
                Read display states from a file.
                """
            class use_active(TUIMethod):
                """
                Update an existing display state's settings to match those of the active graphics window.
                """
            class write(TUIMethod):
                """
                Write display states to a file.
                """

        class embedded_windows(TUIMenu):
            """
            Enter to embed, close, move-out embedded windows.
            """
            def __init__(self, service, version, mode, path):
                self.dashboard = self.__class__.dashboard(service, version, mode, path + ["dashboard"])
                self.close = self.__class__.close(service, version, mode, path + ["close"])
                self.close_all = self.__class__.close_all(service, version, mode, path + ["close_all"])
                self.embed_in = self.__class__.embed_in(service, version, mode, path + ["embed_in"])
                self.move_out = self.__class__.move_out(service, version, mode, path + ["move_out"])
                self.move_out_all = self.__class__.move_out_all(service, version, mode, path + ["move_out_all"])
                self.update_dimensions = self.__class__.update_dimensions(service, version, mode, path + ["update_dimensions"])
                super().__init__(service, version, mode, path)
            class close(TUIMethod):
                """
                Close an embedded window.
                """
            class close_all(TUIMethod):
                """
                Close all embedded windows for given parent window.
                """
            class embed_in(TUIMethod):
                """
                Embed Window into another window.
                """
            class move_out(TUIMethod):
                """
                Move out an embedded window.
                """
            class move_out_all(TUIMethod):
                """
                Move out all embedded windows for given parent window.
                """
            class update_dimensions(TUIMethod):
                """
                Update the embedded windows dimensions.
                """

            class dashboard(TUIMenu):
                """
                Enter to create, edit, delete, display embedded windows dashboards.
                """
                def __init__(self, service, version, mode, path):
                    self.close = self.__class__.close(service, version, mode, path + ["close"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    super().__init__(service, version, mode, path)
                class close(TUIMethod):
                    """
                    Close existing dashboard.
                    """
                class create(TUIMethod):
                    """
                    Create new dashboard.
                    """
                class delete(TUIMethod):
                    """
                    Delete existing dashboard.
                    """
                class display(TUIMethod):
                    """
                    Display existing dashboard.
                    """
                class edit(TUIMethod):
                    """
                    Edit existing dashboard.
                    """
                class list(TUIMethod):
                    """
                    List all dashboards.
                    """

        class flamelet_data(TUIMenu):
            """
            Display flamelet data.
            """
            def __init__(self, service, version, mode, path):
                self.carpet_plot = self.__class__.carpet_plot(service, version, mode, path + ["carpet_plot"])
                self.draw_number_box = self.__class__.draw_number_box(service, version, mode, path + ["draw_number_box"])
                self.plot_1d_slice = self.__class__.plot_1d_slice(service, version, mode, path + ["plot_1d_slice"])
                self.write_to_file = self.__class__.write_to_file(service, version, mode, path + ["write_to_file"])
                super().__init__(service, version, mode, path)
            class carpet_plot(TUIMethod):
                """
                Enable/disable display of carpet plot of a property.
                """
            class draw_number_box(TUIMethod):
                """
                Enable/disable display of the numbers box.
                """
            class plot_1d_slice(TUIMethod):
                """
                Enable/disable plot of the 1D-slice.
                """
            class write_to_file(TUIMethod):
                """
                Enable/disable writing the 1D-slice to file instead of plot.
                """

        class objects(TUIMenu):
            """
            Enter to add, edit, delete or display graphics objects.
            """
            def __init__(self, service, version, mode, path):
                self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.display_in_different_windows = self.__class__.display_in_different_windows(service, version, mode, path + ["display_in_different_windows"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                super().__init__(service, version, mode, path)
            class add_to_graphics(TUIMethod):
                """
                Add graphics object to existing graphics.
                """
            class copy(TUIMethod):
                """
                Copy graphics object.
                """
            class create(TUIMethod):
                """
                Create new graphics object.
                """
            class delete(TUIMethod):
                """
                Delete graphics object.
                """
            class display(TUIMethod):
                """
                Display graphics object.
                """
            class display_in_different_windows(TUIMethod):
                """
                Display graphics objects in diffetent windows.
                """
            class edit(TUIMethod):
                """
                Edit graphics object.
                """

        class particle_tracks(TUIMenu):
            """
            Enter the particle tracks menu.
            """
            def __init__(self, service, version, mode, path):
                self.particle_tracks = self.__class__.particle_tracks(service, version, mode, path + ["particle_tracks"])
                self.plot_write_xy_plot = self.__class__.plot_write_xy_plot(service, version, mode, path + ["plot_write_xy_plot"])
                super().__init__(service, version, mode, path)
            class particle_tracks(TUIMethod):
                """
                Calculate and display particle tracks from defined injections.
                """
            class plot_write_xy_plot(TUIMethod):
                """
                Plot or write XY plot of particle tracks.
                """

        class path_lines(TUIMenu):
            """
            Enter the pathlines menu.
            """
            def __init__(self, service, version, mode, path):
                self.path_lines = self.__class__.path_lines(service, version, mode, path + ["path_lines"])
                self.plot_write_xy_plot = self.__class__.plot_write_xy_plot(service, version, mode, path + ["plot_write_xy_plot"])
                self.write_to_files = self.__class__.write_to_files(service, version, mode, path + ["write_to_files"])
                super().__init__(service, version, mode, path)
            class path_lines(TUIMethod):
                """
                Display pathlines from a surface.
                """
            class plot_write_xy_plot(TUIMethod):
                """
                Plot or write XY plot of pathline.
                """
            class write_to_files(TUIMethod):
                """
                Write Pathlines to a File.
                """

        class pdf_data(TUIMenu):
            """
            Enter the PDF data menu.
            """
            def __init__(self, service, version, mode, path):
                self.carpet_plot = self.__class__.carpet_plot(service, version, mode, path + ["carpet_plot"])
                self.draw_number_box = self.__class__.draw_number_box(service, version, mode, path + ["draw_number_box"])
                self.plot_1d_slice = self.__class__.plot_1d_slice(service, version, mode, path + ["plot_1d_slice"])
                self.write_to_file = self.__class__.write_to_file(service, version, mode, path + ["write_to_file"])
                super().__init__(service, version, mode, path)
            class carpet_plot(TUIMethod):
                """
                Enable/disable the display of a carpet plot of a property.
                """
            class draw_number_box(TUIMethod):
                """
                Enable/disable the display of the numbers box.
                """
            class plot_1d_slice(TUIMethod):
                """
                Enable/disable a plot of the 1D-slice.
                """
            class write_to_file(TUIMethod):
                """
                Enable/disable writing the 1D-slice to file instead of plot.
                """

        class raytracer(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.background = self.__class__.background(service, version, mode, path + ["background"])
                self.rendering = self.__class__.rendering(service, version, mode, path + ["rendering"])
                self.display_live_preview = self.__class__.display_live_preview(service, version, mode, path + ["display_live_preview"])
                super().__init__(service, version, mode, path)
            class display_live_preview(TUIMethod):
                """
                .
                """

            class background(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.activate_env_ground = self.__class__.activate_env_ground(service, version, mode, path + ["activate_env_ground"])
                    self.activate_env_ground_shadow = self.__class__.activate_env_ground_shadow(service, version, mode, path + ["activate_env_ground_shadow"])
                    self.backplate_color = self.__class__.backplate_color(service, version, mode, path + ["backplate_color"])
                    self.backplate_image = self.__class__.backplate_image(service, version, mode, path + ["backplate_image"])
                    self.env_color = self.__class__.env_color(service, version, mode, path + ["env_color"])
                    self.env_intensity = self.__class__.env_intensity(service, version, mode, path + ["env_intensity"])
                    self.env_light_dirvec = self.__class__.env_light_dirvec(service, version, mode, path + ["env_light_dirvec"])
                    self.env_light_ground_height = self.__class__.env_light_ground_height(service, version, mode, path + ["env_light_ground_height"])
                    self.env_light_upvec = self.__class__.env_light_upvec(service, version, mode, path + ["env_light_upvec"])
                    self.environment_image = self.__class__.environment_image(service, version, mode, path + ["environment_image"])
                    self.ground_shadow_axis = self.__class__.ground_shadow_axis(service, version, mode, path + ["ground_shadow_axis"])
                    self.hide_environment_keep_effects = self.__class__.hide_environment_keep_effects(service, version, mode, path + ["hide_environment_keep_effects"])
                    self.horizontal = self.__class__.horizontal(service, version, mode, path + ["horizontal"])
                    self.is_ground_shadow_at_fix_axis = self.__class__.is_ground_shadow_at_fix_axis(service, version, mode, path + ["is_ground_shadow_at_fix_axis"])
                    self.model_scale = self.__class__.model_scale(service, version, mode, path + ["model_scale"])
                    self.show_backplate = self.__class__.show_backplate(service, version, mode, path + ["show_backplate"])
                    self.spin = self.__class__.spin(service, version, mode, path + ["spin"])
                    self.vertical = self.__class__.vertical(service, version, mode, path + ["vertical"])
                    self.view_zoom = self.__class__.view_zoom(service, version, mode, path + ["view_zoom"])
                    super().__init__(service, version, mode, path)
                class activate_env_ground(TUIMethod):
                    """
                    .
                    """
                class activate_env_ground_shadow(TUIMethod):
                    """
                    .
                    """
                class backplate_color(TUIMethod):
                    """
                    .
                    """
                class backplate_image(TUIMethod):
                    """
                    .
                    """
                class env_color(TUIMethod):
                    """
                    .
                    """
                class env_intensity(TUIMethod):
                    """
                    .
                    """
                class env_light_dirvec(TUIMethod):
                    """
                    .
                    """
                class env_light_ground_height(TUIMethod):
                    """
                    .
                    """
                class env_light_upvec(TUIMethod):
                    """
                    .
                    """
                class environment_image(TUIMethod):
                    """
                    .
                    """
                class ground_shadow_axis(TUIMethod):
                    """
                    .
                    """
                class hide_environment_keep_effects(TUIMethod):
                    """
                    .
                    """
                class horizontal(TUIMethod):
                    """
                    .
                    """
                class is_ground_shadow_at_fix_axis(TUIMethod):
                    """
                    .
                    """
                class model_scale(TUIMethod):
                    """
                    .
                    """
                class show_backplate(TUIMethod):
                    """
                    .
                    """
                class spin(TUIMethod):
                    """
                    .
                    """
                class vertical(TUIMethod):
                    """
                    .
                    """
                class view_zoom(TUIMethod):
                    """
                    .
                    """

            class rendering(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.denoiser = self.__class__.denoiser(service, version, mode, path + ["denoiser"])
                    self.max_rendering_timeout = self.__class__.max_rendering_timeout(service, version, mode, path + ["max_rendering_timeout"])
                    self.quality = self.__class__.quality(service, version, mode, path + ["quality"])
                    self.thread_count = self.__class__.thread_count(service, version, mode, path + ["thread_count"])
                    super().__init__(service, version, mode, path)
                class denoiser(TUIMethod):
                    """
                    .
                    """
                class max_rendering_timeout(TUIMethod):
                    """
                    .
                    """
                class quality(TUIMethod):
                    """
                    .
                    """
                class thread_count(TUIMethod):
                    """
                    .
                    """

        class set(TUIMenu):
            """
            Enter the set menu to set display parameters.
            """
            def __init__(self, service, version, mode, path):
                self.colors = self.__class__.colors(service, version, mode, path + ["colors"])
                self.contours = self.__class__.contours(service, version, mode, path + ["contours"])
                self.lights = self.__class__.lights(service, version, mode, path + ["lights"])
                self.particle_tracks = self.__class__.particle_tracks(service, version, mode, path + ["particle_tracks"])
                self.path_lines = self.__class__.path_lines(service, version, mode, path + ["path_lines"])
                self.picture = self.__class__.picture(service, version, mode, path + ["picture"])
                self.rendering_options = self.__class__.rendering_options(service, version, mode, path + ["rendering_options"])
                self.titles = self.__class__.titles(service, version, mode, path + ["titles"])
                self.velocity_vectors = self.__class__.velocity_vectors(service, version, mode, path + ["velocity_vectors"])
                self.windows = self.__class__.windows(service, version, mode, path + ["windows"])
                self.color_map = self.__class__.color_map(service, version, mode, path + ["color_map"])
                self.duplicate_node_display = self.__class__.duplicate_node_display(service, version, mode, path + ["duplicate_node_display"])
                self.element_shrink = self.__class__.element_shrink(service, version, mode, path + ["element_shrink"])
                self.filled_grid = self.__class__.filled_grid(service, version, mode, path + ["filled_grid"])
                self.filled_mesh = self.__class__.filled_mesh(service, version, mode, path + ["filled_mesh"])
                self.grid_level = self.__class__.grid_level(service, version, mode, path + ["grid_level"])
                self.grid_partitions = self.__class__.grid_partitions(service, version, mode, path + ["grid_partitions"])
                self.grid_surfaces = self.__class__.grid_surfaces(service, version, mode, path + ["grid_surfaces"])
                self.grid_zones = self.__class__.grid_zones(service, version, mode, path + ["grid_zones"])
                self.line_weight = self.__class__.line_weight(service, version, mode, path + ["line_weight"])
                self.marker_size = self.__class__.marker_size(service, version, mode, path + ["marker_size"])
                self.marker_symbol = self.__class__.marker_symbol(service, version, mode, path + ["marker_symbol"])
                self.mesh_display_configuration = self.__class__.mesh_display_configuration(service, version, mode, path + ["mesh_display_configuration"])
                self.mesh_level = self.__class__.mesh_level(service, version, mode, path + ["mesh_level"])
                self.mesh_partitions = self.__class__.mesh_partitions(service, version, mode, path + ["mesh_partitions"])
                self.mesh_surfaces = self.__class__.mesh_surfaces(service, version, mode, path + ["mesh_surfaces"])
                self.mesh_zones = self.__class__.mesh_zones(service, version, mode, path + ["mesh_zones"])
                self.mirror_zones = self.__class__.mirror_zones(service, version, mode, path + ["mirror_zones"])
                self.n_stream_func = self.__class__.n_stream_func(service, version, mode, path + ["n_stream_func"])
                self.nodewt_based_interp = self.__class__.nodewt_based_interp(service, version, mode, path + ["nodewt_based_interp"])
                self.overlays = self.__class__.overlays(service, version, mode, path + ["overlays"])
                self.periodic_instancing = self.__class__.periodic_instancing(service, version, mode, path + ["periodic_instancing"])
                self.periodic_repeats = self.__class__.periodic_repeats(service, version, mode, path + ["periodic_repeats"])
                self.proximity_zones = self.__class__.proximity_zones(service, version, mode, path + ["proximity_zones"])
                self.render_mesh = self.__class__.render_mesh(service, version, mode, path + ["render_mesh"])
                self.reset_graphics = self.__class__.reset_graphics(service, version, mode, path + ["reset_graphics"])
                self.zero_angle_dir = self.__class__.zero_angle_dir(service, version, mode, path + ["zero_angle_dir"])
                super().__init__(service, version, mode, path)
            class color_map(TUIMethod):
                """
                Enter the color-map menu.
                """
            class duplicate_node_display(TUIMethod):
                """
                Set flag to remove duplicate nodes in mesh display.
                """
            class element_shrink(TUIMethod):
                """
                Set percentage to shrink elements.
                """
            class filled_grid(TUIMethod):
                """
                Enable/disable the filled mesh option.
                """
            class filled_mesh(TUIMethod):
                """
                Enable/disable the filled mesh option.
                """
            class grid_level(TUIMethod):
                """
                Set coarse mesh level to be drawn.
                """
            class grid_partitions(TUIMethod):
                """
                Enable/disable drawing of the mesh partition boundaries.
                """
            class grid_surfaces(TUIMethod):
                """
                Set surface IDs to be drawn as mesh.
                """
            class grid_zones(TUIMethod):
                """
                Set zone IDs to be drawn as mesh.
                """
            class line_weight(TUIMethod):
                """
                Set the line-weight factor for the window.
                """
            class marker_size(TUIMethod):
                """
                Set the size of markers used to represent points.
                """
            class marker_symbol(TUIMethod):
                """
                Set the type of markers used to represent points.
                """
            class mesh_display_configuration(TUIMethod):
                """
                Set mesh display configuration.
                """
            class mesh_level(TUIMethod):
                """
                Set coarse mesh level to be drawn.
                """
            class mesh_partitions(TUIMethod):
                """
                Enable/disable drawing of the mesh partition boundaries.
                """
            class mesh_surfaces(TUIMethod):
                """
                Set surface IDs to be drawn as mesh.
                """
            class mesh_zones(TUIMethod):
                """
                Set zone IDs to be drawn as mesh.
                """
            class mirror_zones(TUIMethod):
                """
                Set zones to mirror the domain about.
                """
            class n_stream_func(TUIMethod):
                """
                Set the number of iterations used in computing stream function.
                """
            class nodewt_based_interp(TUIMethod):
                """
                Use more accurate node-weight based interpolation for postprocessing.
                """
            class overlays(TUIMethod):
                """
                Enable/disable overlays.
                """
            class periodic_instancing(TUIMethod):
                """
                Set periodic instancing.
                """
            class periodic_repeats(TUIMethod):
                """
                Set periodic instancing.
                """
            class proximity_zones(TUIMethod):
                """
                Set zones to be used for boundary cell distance and boundary proximity.
                """
            class render_mesh(TUIMethod):
                """
                Enable/disable rendering the mesh on top of contours, vectors, etc.
                """
            class reset_graphics(TUIMethod):
                """
                Reset the graphics system.
                """
            class zero_angle_dir(TUIMethod):
                """
                Set the vector having zero angular coordinates.
                """

            class colors(TUIMenu):
                """
                Enter the color options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.by_surface = self.__class__.by_surface(service, version, mode, path + ["by_surface"])
                    self.by_type = self.__class__.by_type(service, version, mode, path + ["by_type"])
                    self.automatic_skip = self.__class__.automatic_skip(service, version, mode, path + ["automatic_skip"])
                    self.axis_faces = self.__class__.axis_faces(service, version, mode, path + ["axis_faces"])
                    self.background = self.__class__.background(service, version, mode, path + ["background"])
                    self.color_by_type = self.__class__.color_by_type(service, version, mode, path + ["color_by_type"])
                    self.far_field_faces = self.__class__.far_field_faces(service, version, mode, path + ["far_field_faces"])
                    self.foreground = self.__class__.foreground(service, version, mode, path + ["foreground"])
                    self.free_surface_faces = self.__class__.free_surface_faces(service, version, mode, path + ["free_surface_faces"])
                    self.graphics_color_theme = self.__class__.graphics_color_theme(service, version, mode, path + ["graphics_color_theme"])
                    self.grid_inlet = self.__class__.grid_inlet(service, version, mode, path + ["grid_inlet"])
                    self.grid_interior = self.__class__.grid_interior(service, version, mode, path + ["grid_interior"])
                    self.highlight_color = self.__class__.highlight_color(service, version, mode, path + ["highlight_color"])
                    self.inlet_faces = self.__class__.inlet_faces(service, version, mode, path + ["inlet_faces"])
                    self.interface_faces = self.__class__.interface_faces(service, version, mode, path + ["interface_faces"])
                    self.interior_faces = self.__class__.interior_faces(service, version, mode, path + ["interior_faces"])
                    self.internal_faces = self.__class__.internal_faces(service, version, mode, path + ["internal_faces"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.outlet_faces = self.__class__.outlet_faces(service, version, mode, path + ["outlet_faces"])
                    self.overset_faces = self.__class__.overset_faces(service, version, mode, path + ["overset_faces"])
                    self.periodic_faces = self.__class__.periodic_faces(service, version, mode, path + ["periodic_faces"])
                    self.rans_les_interface_faces = self.__class__.rans_les_interface_faces(service, version, mode, path + ["rans_les_interface_faces"])
                    self.reset_colors = self.__class__.reset_colors(service, version, mode, path + ["reset_colors"])
                    self.reset_user_colors = self.__class__.reset_user_colors(service, version, mode, path + ["reset_user_colors"])
                    self.show_user_colors = self.__class__.show_user_colors(service, version, mode, path + ["show_user_colors"])
                    self.skip_label = self.__class__.skip_label(service, version, mode, path + ["skip_label"])
                    self.surface = self.__class__.surface(service, version, mode, path + ["surface"])
                    self.symmetry_faces = self.__class__.symmetry_faces(service, version, mode, path + ["symmetry_faces"])
                    self.traction_faces = self.__class__.traction_faces(service, version, mode, path + ["traction_faces"])
                    self.user_color = self.__class__.user_color(service, version, mode, path + ["user_color"])
                    self.wall_faces = self.__class__.wall_faces(service, version, mode, path + ["wall_faces"])
                    super().__init__(service, version, mode, path)
                class automatic_skip(TUIMethod):
                    """
                    Determine whether to skip labels in the colopmap scale automatically.
                    """
                class axis_faces(TUIMethod):
                    """
                    Set the color of axisymmetric faces.
                    """
                class background(TUIMethod):
                    """
                    Set the background (window) color.
                    """
                class color_by_type(TUIMethod):
                    """
                    Determine whether to color meshes by type or by surface (ID).
                    """
                class far_field_faces(TUIMethod):
                    """
                    Set the color of far field faces.
                    """
                class foreground(TUIMethod):
                    """
                    Set the foreground (text and window frame) color.
                    """
                class free_surface_faces(TUIMethod):
                    """
                    Set the color of free-surface faces.
                    """
                class graphics_color_theme(TUIMethod):
                    """
                    Enter the graphics color theme menu.
                    """
                class grid_inlet(TUIMethod):
                    """
                    Set the color of inlet faces.
                    """
                class grid_interior(TUIMethod):
                    """
                    Set the color of interior faces.
                    """
                class highlight_color(TUIMethod):
                    """
                    Set highlight color.
                    """
                class inlet_faces(TUIMethod):
                    """
                    Set the color of inlet faces.
                    """
                class interface_faces(TUIMethod):
                    """
                    Set the color of mesh Interfaces.
                    """
                class interior_faces(TUIMethod):
                    """
                    Set the color of interior faces.
                    """
                class internal_faces(TUIMethod):
                    """
                    Set the color of internal interface faces.
                    """
                class list(TUIMethod):
                    """
                    List available colors.
                    """
                class outlet_faces(TUIMethod):
                    """
                    Set the color of outlet faces.
                    """
                class overset_faces(TUIMethod):
                    """
                    Set the color of overset faces.
                    """
                class periodic_faces(TUIMethod):
                    """
                    Set the color of periodic faces.
                    """
                class rans_les_interface_faces(TUIMethod):
                    """
                    Set the color of RANS/LES interface faces.
                    """
                class reset_colors(TUIMethod):
                    """
                    Reset individual mesh surface colors to the defaults.
                    """
                class reset_user_colors(TUIMethod):
                    """
                    Reset all user colors.
                    """
                class show_user_colors(TUIMethod):
                    """
                    List currently defined user colors.
                    """
                class skip_label(TUIMethod):
                    """
                    Set the number of labels to be skipped in the colopmap scale.
                    """
                class surface(TUIMethod):
                    """
                    Set the color of surfaces.
                    """
                class symmetry_faces(TUIMethod):
                    """
                    Set the color of symmetric faces.
                    """
                class traction_faces(TUIMethod):
                    """
                    Set the color of traction faces.
                    """
                class user_color(TUIMethod):
                    """
                    Explicitly set color of display zone.
                    """
                class wall_faces(TUIMethod):
                    """
                    Set the color of wall faces.
                    """

                class by_surface(TUIMenu):
                    """
                    Enter the surface(s) color and material assignment menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.list_surfaces_by_color = self.__class__.list_surfaces_by_color(service, version, mode, path + ["list_surfaces_by_color"])
                        self.list_surfaces_by_material = self.__class__.list_surfaces_by_material(service, version, mode, path + ["list_surfaces_by_material"])
                        self.reset = self.__class__.reset(service, version, mode, path + ["reset"])
                        self.surfaces = self.__class__.surfaces(service, version, mode, path + ["surfaces"])
                        self.use_inherent_material_color = self.__class__.use_inherent_material_color(service, version, mode, path + ["use_inherent_material_color"])
                        super().__init__(service, version, mode, path)
                    class list_surfaces_by_color(TUIMethod):
                        """
                        To list the surfaces by its color.
                        """
                    class list_surfaces_by_material(TUIMethod):
                        """
                        To list the surfaces by its material.
                        """
                    class reset(TUIMethod):
                        """
                        To reset colors and/or materials to the defaults.
                        """
                    class surfaces(TUIMethod):
                        """
                        Select the surface(s) to specify colors and/or materials.
                        """
                    class use_inherent_material_color(TUIMethod):
                        """
                        Use inherent material color for surfaces.
                        """

                class by_type(TUIMenu):
                    """
                    Enter the zone type color and material assignment menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.type_name = self.__class__.type_name(service, version, mode, path + ["type_name"])
                        self.only_list_case_boundaries = self.__class__.only_list_case_boundaries(service, version, mode, path + ["only_list_case_boundaries"])
                        self.reset = self.__class__.reset(service, version, mode, path + ["reset"])
                        self.use_inherent_material_color = self.__class__.use_inherent_material_color(service, version, mode, path + ["use_inherent_material_color"])
                        super().__init__(service, version, mode, path)
                    class only_list_case_boundaries(TUIMethod):
                        """
                        Only list the boundary types that are assigned in this case.
                        """
                    class reset(TUIMethod):
                        """
                        To reset colors and/or materials to the defaults.
                        """
                    class use_inherent_material_color(TUIMethod):
                        """
                        Use inherent material color for boundary zones.
                        """

                    class type_name(TUIMenu):
                        """
                        Select the boundary type to specify colors and/or materials.
                        """
                        def __init__(self, service, version, mode, path):
                            self.axis = self.__class__.axis(service, version, mode, path + ["axis"])
                            self.far_field = self.__class__.far_field(service, version, mode, path + ["far_field"])
                            self.free_surface = self.__class__.free_surface(service, version, mode, path + ["free_surface"])
                            self.inlet = self.__class__.inlet(service, version, mode, path + ["inlet"])
                            self.interface = self.__class__.interface(service, version, mode, path + ["interface"])
                            self.interior = self.__class__.interior(service, version, mode, path + ["interior"])
                            self.internal = self.__class__.internal(service, version, mode, path + ["internal"])
                            self.outlet = self.__class__.outlet(service, version, mode, path + ["outlet"])
                            self.overset = self.__class__.overset(service, version, mode, path + ["overset"])
                            self.periodic = self.__class__.periodic(service, version, mode, path + ["periodic"])
                            self.rans_les_interface = self.__class__.rans_les_interface(service, version, mode, path + ["rans_les_interface"])
                            self.surface = self.__class__.surface(service, version, mode, path + ["surface"])
                            self.symmetry = self.__class__.symmetry(service, version, mode, path + ["symmetry"])
                            self.traction = self.__class__.traction(service, version, mode, path + ["traction"])
                            self.wall = self.__class__.wall(service, version, mode, path + ["wall"])
                            super().__init__(service, version, mode, path)

                        class axis(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class far_field(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class free_surface(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class inlet(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class interface(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class interior(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class internal(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class outlet(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class overset(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class periodic(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class rans_les_interface(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class surface(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class symmetry(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class traction(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

                        class wall(TUIMenu):
                            """
                            Set the material and/or color for the selected boundary type.
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.material = self.__class__.material(service, version, mode, path + ["material"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                Set a color for the selected boundary type.
                                """
                            class material(TUIMethod):
                                """
                                Set a material for the selected boundary type.
                                """

            class contours(TUIMenu):
                """
                Enter the contour options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                    self.clip_to_range = self.__class__.clip_to_range(service, version, mode, path + ["clip_to_range"])
                    self.coloring = self.__class__.coloring(service, version, mode, path + ["coloring"])
                    self.filled_contours = self.__class__.filled_contours(service, version, mode, path + ["filled_contours"])
                    self.global_range = self.__class__.global_range(service, version, mode, path + ["global_range"])
                    self.line_contours = self.__class__.line_contours(service, version, mode, path + ["line_contours"])
                    self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                    self.n_contour = self.__class__.n_contour(service, version, mode, path + ["n_contour"])
                    self.node_values = self.__class__.node_values(service, version, mode, path + ["node_values"])
                    self.render_mesh = self.__class__.render_mesh(service, version, mode, path + ["render_mesh"])
                    self.surfaces = self.__class__.surfaces(service, version, mode, path + ["surfaces"])
                    super().__init__(service, version, mode, path)
                class auto_range(TUIMethod):
                    """
                    Enable/disable auto-computation of range for contours.
                    """
                class clip_to_range(TUIMethod):
                    """
                    Enable/disable the clip to range option for filled contours.
                    """
                class coloring(TUIMethod):
                    """
                    Select coloring option.
                    """
                class filled_contours(TUIMethod):
                    """
                    Enable/disable the filled contour option.
                    """
                class global_range(TUIMethod):
                    """
                    Enable/disable the global range for contours option.
                    """
                class line_contours(TUIMethod):
                    """
                    Enable/disable the filled contour option.
                    """
                class log_scale(TUIMethod):
                    """
                    Enable/disable the use of a log scale.
                    """
                class n_contour(TUIMethod):
                    """
                    Set the number of contour levels.
                    """
                class node_values(TUIMethod):
                    """
                    Enable/disable the plot of node values.
                    """
                class render_mesh(TUIMethod):
                    """
                    Determine whether or not to render the mesh on top of contours, vectors, etc.
                    """
                class surfaces(TUIMethod):
                    """
                    Set surfaces to be contoured.
                    """

            class lights(TUIMenu):
                """
                Enter the lights menu.
                """
                def __init__(self, service, version, mode, path):
                    self.headlight_on = self.__class__.headlight_on(service, version, mode, path + ["headlight_on"])
                    self.lighting_interpolation = self.__class__.lighting_interpolation(service, version, mode, path + ["lighting_interpolation"])
                    self.lights_on = self.__class__.lights_on(service, version, mode, path + ["lights_on"])
                    self.set_ambient_color = self.__class__.set_ambient_color(service, version, mode, path + ["set_ambient_color"])
                    self.set_light = self.__class__.set_light(service, version, mode, path + ["set_light"])
                    super().__init__(service, version, mode, path)
                class headlight_on(TUIMethod):
                    """
                    Turn the light that moves with the camera on or off.
                    """
                class lighting_interpolation(TUIMethod):
                    """
                    Set lighting interpolation method.
                    """
                class lights_on(TUIMethod):
                    """
                    Turn all active lighting on/off.
                    """
                class set_ambient_color(TUIMethod):
                    """
                    Set the ambient light color for the scene.
                    """
                class set_light(TUIMethod):
                    """
                    Add or modify a directional, colored light.
                    """

            class particle_tracks(TUIMenu):
                """
                Enter the particle-tracks menu to set parameters for display of particle tracks.
                """
                def __init__(self, service, version, mode, path):
                    self.filter_settings = self.__class__.filter_settings(service, version, mode, path + ["filter_settings"])
                    self.sphere_settings = self.__class__.sphere_settings(service, version, mode, path + ["sphere_settings"])
                    self.vector_settings = self.__class__.vector_settings(service, version, mode, path + ["vector_settings"])
                    self.arrow_scale = self.__class__.arrow_scale(service, version, mode, path + ["arrow_scale"])
                    self.arrow_space = self.__class__.arrow_space(service, version, mode, path + ["arrow_space"])
                    self.coarsen_factor = self.__class__.coarsen_factor(service, version, mode, path + ["coarsen_factor"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.history_filename = self.__class__.history_filename(service, version, mode, path + ["history_filename"])
                    self.line_width = self.__class__.line_width(service, version, mode, path + ["line_width"])
                    self.marker_size = self.__class__.marker_size(service, version, mode, path + ["marker_size"])
                    self.particle_skip = self.__class__.particle_skip(service, version, mode, path + ["particle_skip"])
                    self.radius = self.__class__.radius(service, version, mode, path + ["radius"])
                    self.report_default_variables = self.__class__.report_default_variables(service, version, mode, path + ["report_default_variables"])
                    self.report_to = self.__class__.report_to(service, version, mode, path + ["report_to"])
                    self.report_type = self.__class__.report_type(service, version, mode, path + ["report_type"])
                    self.report_variables = self.__class__.report_variables(service, version, mode, path + ["report_variables"])
                    self.sphere_attrib = self.__class__.sphere_attrib(service, version, mode, path + ["sphere_attrib"])
                    self.style = self.__class__.style(service, version, mode, path + ["style"])
                    self.track_single_particle_stream = self.__class__.track_single_particle_stream(service, version, mode, path + ["track_single_particle_stream"])
                    self.twist_factor = self.__class__.twist_factor(service, version, mode, path + ["twist_factor"])
                    super().__init__(service, version, mode, path)
                class arrow_scale(TUIMethod):
                    """
                    Set the scale factor for arrows drawn on particle tracks.
                    """
                class arrow_space(TUIMethod):
                    """
                    Set the spacing factor for arrows drawn on particle tracks.
                    """
                class coarsen_factor(TUIMethod):
                    """
                    Set the particle tracks coarsening factor.
                    """
                class display(TUIMethod):
                    """
                    Determine whether particle tracks will be displayed or only tracked.
                    """
                class history_filename(TUIMethod):
                    """
                    Specify the name of the particle history file.
                    """
                class line_width(TUIMethod):
                    """
                    Set the width for particle track.
                    """
                class marker_size(TUIMethod):
                    """
                    Set the marker size for particle drawing.
                    """
                class particle_skip(TUIMethod):
                    """
                    Specify how many particle tracks should be displayed.
                    """
                class radius(TUIMethod):
                    """
                    Set the radius for particle track (ribbons/cylinder only) cross-section.
                    """
                class report_default_variables(TUIMethod):
                    """
                    Set the report variables to default.
                    """
                class report_to(TUIMethod):
                    """
                    Specify the destination for the report (console, file, none).
                    """
                class report_type(TUIMethod):
                    """
                    Set the report type for particle tracks.
                    """
                class report_variables(TUIMethod):
                    """
                    Set the report variables.
                    """
                class sphere_attrib(TUIMethod):
                    """
                    Specify size and number of slices to be used in drawing spheres.
                    """
                class style(TUIMethod):
                    """
                    Set the display style for particle track (line/ribbon/cylinder/sphere).
                    """
                class track_single_particle_stream(TUIMethod):
                    """
                    Specify the stream ID to be tracked.
                    """
                class twist_factor(TUIMethod):
                    """
                    Set the scale factor for twisting (ribbons only).
                    """

                class filter_settings(TUIMenu):
                    """
                    Set filter for particle display.
                    """
                    def __init__(self, service, version, mode, path):
                        self.enable_filtering = self.__class__.enable_filtering(service, version, mode, path + ["enable_filtering"])
                        self.filter_variable = self.__class__.filter_variable(service, version, mode, path + ["filter_variable"])
                        self.inside = self.__class__.inside(service, version, mode, path + ["inside"])
                        self.maximum = self.__class__.maximum(service, version, mode, path + ["maximum"])
                        self.minimum = self.__class__.minimum(service, version, mode, path + ["minimum"])
                        super().__init__(service, version, mode, path)
                    class enable_filtering(TUIMethod):
                        """
                        Specify whether particle display is filtered.
                        """
                    class filter_variable(TUIMethod):
                        """
                        Select a variable used for filtering of particles.
                        """
                    class inside(TUIMethod):
                        """
                        Specify whether filter variable needs to be inside min/max to be displayed (else outside min/max).
                        """
                    class maximum(TUIMethod):
                        """
                        Specify the upper bound for the filter variable.
                        """
                    class minimum(TUIMethod):
                        """
                        Specify the lower bound for the filter variable.
                        """

                class sphere_settings(TUIMenu):
                    """
                    Provide sphere specific input.
                    """
                    def __init__(self, service, version, mode, path):
                        self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                        self.diameter = self.__class__.diameter(service, version, mode, path + ["diameter"])
                        self.maximum = self.__class__.maximum(service, version, mode, path + ["maximum"])
                        self.minimum = self.__class__.minimum(service, version, mode, path + ["minimum"])
                        self.scale_factor = self.__class__.scale_factor(service, version, mode, path + ["scale_factor"])
                        self.size_variable = self.__class__.size_variable(service, version, mode, path + ["size_variable"])
                        self.smooth_parameter = self.__class__.smooth_parameter(service, version, mode, path + ["smooth_parameter"])
                        self.vary_diameter = self.__class__.vary_diameter(service, version, mode, path + ["vary_diameter"])
                        super().__init__(service, version, mode, path)
                    class auto_range(TUIMethod):
                        """
                        Specify whether displayed spheres should include auto range of variable to size spheres.
                        """
                    class diameter(TUIMethod):
                        """
                        Diameter of the spheres when vary-diameter? is disabled.
                        """
                    class maximum(TUIMethod):
                        """
                        Set the maximum value of the sphere to be displayed.
                        """
                    class minimum(TUIMethod):
                        """
                        Set the minimum value of the sphere to be displayed.
                        """
                    class scale_factor(TUIMethod):
                        """
                        Specify a scale factor to enlarge/reduce the size of spheres.
                        """
                    class size_variable(TUIMethod):
                        """
                        Select a particle variable to size the spheres.
                        """
                    class smooth_parameter(TUIMethod):
                        """
                        Specify number of slices to be used in drawing spheres.
                        """
                    class vary_diameter(TUIMethod):
                        """
                        Specify whether the spheres can vary with another variable.
                        """

                class vector_settings(TUIMenu):
                    """
                    Set vector specific input.
                    """
                    def __init__(self, service, version, mode, path):
                        self.color_variable = self.__class__.color_variable(service, version, mode, path + ["color_variable"])
                        self.constant_color = self.__class__.constant_color(service, version, mode, path + ["constant_color"])
                        self.length_to_head_ratio = self.__class__.length_to_head_ratio(service, version, mode, path + ["length_to_head_ratio"])
                        self.length_variable = self.__class__.length_variable(service, version, mode, path + ["length_variable"])
                        self.scale_factor = self.__class__.scale_factor(service, version, mode, path + ["scale_factor"])
                        self.style = self.__class__.style(service, version, mode, path + ["style"])
                        self.vector_length = self.__class__.vector_length(service, version, mode, path + ["vector_length"])
                        self.vector_length_variable = self.__class__.vector_length_variable(service, version, mode, path + ["vector_length_variable"])
                        self.vector_variable = self.__class__.vector_variable(service, version, mode, path + ["vector_variable"])
                        super().__init__(service, version, mode, path)
                    class color_variable(TUIMethod):
                        """
                        Specify whether the vectors should be colored by variable specified in /display/particle-track/particle-track (if false use a constant color).
                        """
                    class constant_color(TUIMethod):
                        """
                        Specify a constant color for the vectors.
                        """
                    class length_to_head_ratio(TUIMethod):
                        """
                        Specify ratio of length to head for vectors and length to diameter for cylinders.
                        """
                    class length_variable(TUIMethod):
                        """
                        Specify whether the displayed vectors have length varying with another variable.
                        """
                    class scale_factor(TUIMethod):
                        """
                        Specify a scale factor to enlarge/reduce the length of vectors.
                        """
                    class style(TUIMethod):
                        """
                        Enable and set the display style for particle vectors (none/vector/centered-vector/centered-cylinder).
                        """
                    class vector_length(TUIMethod):
                        """
                        Specify the length of constant vectors.
                        """
                    class vector_length_variable(TUIMethod):
                        """
                        Select a particle variable to specify the length of vectors.
                        """
                    class vector_variable(TUIMethod):
                        """
                        Select a particle vector function to specify vector direction.
                        """

            class path_lines(TUIMenu):
                """
                Enter the path-lines menu to set parameters for the display of pathlines.
                """
                def __init__(self, service, version, mode, path):
                    self.arrow_scale = self.__class__.arrow_scale(service, version, mode, path + ["arrow_scale"])
                    self.arrow_space = self.__class__.arrow_space(service, version, mode, path + ["arrow_space"])
                    self.display_steps = self.__class__.display_steps(service, version, mode, path + ["display_steps"])
                    self.error_control = self.__class__.error_control(service, version, mode, path + ["error_control"])
                    self.line_width = self.__class__.line_width(service, version, mode, path + ["line_width"])
                    self.marker_size = self.__class__.marker_size(service, version, mode, path + ["marker_size"])
                    self.maximum_error = self.__class__.maximum_error(service, version, mode, path + ["maximum_error"])
                    self.maximum_steps = self.__class__.maximum_steps(service, version, mode, path + ["maximum_steps"])
                    self.radius = self.__class__.radius(service, version, mode, path + ["radius"])
                    self.relative_pathlines = self.__class__.relative_pathlines(service, version, mode, path + ["relative_pathlines"])
                    self.reverse = self.__class__.reverse(service, version, mode, path + ["reverse"])
                    self.sphere_attrib = self.__class__.sphere_attrib(service, version, mode, path + ["sphere_attrib"])
                    self.step_size = self.__class__.step_size(service, version, mode, path + ["step_size"])
                    self.style = self.__class__.style(service, version, mode, path + ["style"])
                    self.track_in_phase = self.__class__.track_in_phase(service, version, mode, path + ["track_in_phase"])
                    self.twist_factor = self.__class__.twist_factor(service, version, mode, path + ["twist_factor"])
                    super().__init__(service, version, mode, path)
                class arrow_scale(TUIMethod):
                    """
                    Set the scale factor for arrows drawn on pathlines.
                    """
                class arrow_space(TUIMethod):
                    """
                    Set the spacing factor for arrows drawn on pathlines.
                    """
                class display_steps(TUIMethod):
                    """
                    Set the display stepping for pathlines.
                    """
                class error_control(TUIMethod):
                    """
                    Set error control during pathline computation.
                    """
                class line_width(TUIMethod):
                    """
                    Set the width for pathlines.
                    """
                class marker_size(TUIMethod):
                    """
                    Set the marker size for particle drawing.
                    """
                class maximum_error(TUIMethod):
                    """
                    Set the maximum error allowed while computing the pathlines.
                    """
                class maximum_steps(TUIMethod):
                    """
                    Set the maximum number of steps to take for pathlines.
                    """
                class radius(TUIMethod):
                    """
                    Set the radius for pathline (ribbons/cylinder only) cross-section.
                    """
                class relative_pathlines(TUIMethod):
                    """
                    Enable/disable the tracking of pathlines in a relative coordinate system.
                    """
                class reverse(TUIMethod):
                    """
                    Enable/disable the direction of path tracking.
                    """
                class sphere_attrib(TUIMethod):
                    """
                    Specify size and no. of slices to be used in drawing sphere for sphere-style.
                    """
                class step_size(TUIMethod):
                    """
                    Set the step length between particle positions for path-lines.
                    """
                class style(TUIMethod):
                    """
                    Set display style for pathlines (line/ribbon/cylinder).
                    """
                class track_in_phase(TUIMethod):
                    """
                    Assign phase to display pathlines in.
                    """
                class twist_factor(TUIMethod):
                    """
                    Set the scale factor for twisting (ribbons only).
                    """

            class picture(TUIMenu):
                """
                Enter the hardcopy/save-picture options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.color_mode = self.__class__.color_mode(service, version, mode, path + ["color_mode"])
                    self.driver = self.__class__.driver(service, version, mode, path + ["driver"])
                    self.dpi = self.__class__.dpi(service, version, mode, path + ["dpi"])
                    self.invert_background = self.__class__.invert_background(service, version, mode, path + ["invert_background"])
                    self.invert_normals_for_avz = self.__class__.invert_normals_for_avz(service, version, mode, path + ["invert_normals_for_avz"])
                    self.jpeg_hardcopy_quality = self.__class__.jpeg_hardcopy_quality(service, version, mode, path + ["jpeg_hardcopy_quality"])
                    self.landscape = self.__class__.landscape(service, version, mode, path + ["landscape"])
                    self.preview = self.__class__.preview(service, version, mode, path + ["preview"])
                    self.raytracer_image = self.__class__.raytracer_image(service, version, mode, path + ["raytracer_image"])
                    self.set_standard_resolution = self.__class__.set_standard_resolution(service, version, mode, path + ["set_standard_resolution"])
                    self.use_window_resolution = self.__class__.use_window_resolution(service, version, mode, path + ["use_window_resolution"])
                    self.x_resolution = self.__class__.x_resolution(service, version, mode, path + ["x_resolution"])
                    self.y_resolution = self.__class__.y_resolution(service, version, mode, path + ["y_resolution"])
                    super().__init__(service, version, mode, path)
                class dpi(TUIMethod):
                    """
                    Set the DPI for EPS and Postscript files, specifies the resolution in dots per inch (DPI) instead of setting the width and height.
                    """
                class invert_background(TUIMethod):
                    """
                    Use a white background when the picture is saved.
                    """
                class invert_normals_for_avz(TUIMethod):
                    """
                    In some cases, images exported to AVZ appear dark and do not match the true colors seen in the graphics window display. Enable 'invert-normals-for-avz' if you experience this issue.
                    """
                class jpeg_hardcopy_quality(TUIMethod):
                    """
                    To set jpeg hardcopy quality.
                    """
                class landscape(TUIMethod):
                    """
                    Plot hardcopies in landscape or portrait orientation.
                    """
                class preview(TUIMethod):
                    """
                    Display a preview image of a hardcopy.
                    """
                class raytracer_image(TUIMethod):
                    """
                    Enable raytracering rendering.
                    """
                class set_standard_resolution(TUIMethod):
                    """
                    Select from pre-defined resolution list.
                    """
                class use_window_resolution(TUIMethod):
                    """
                    Use the currently active window's resolution for hardcopy (ignores the x-resolution and y-resolution in this case).
                    """
                class x_resolution(TUIMethod):
                    """
                    Set the width of raster-formatted images in pixels (0 implies current window size).
                    """
                class y_resolution(TUIMethod):
                    """
                    Set the height of raster-formatted images in pixels (0 implies current window size).
                    """

                class color_mode(TUIMenu):
                    """
                    Enter the hardcopy color mode menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.color = self.__class__.color(service, version, mode, path + ["color"])
                        self.gray_scale = self.__class__.gray_scale(service, version, mode, path + ["gray_scale"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.mono_chrome = self.__class__.mono_chrome(service, version, mode, path + ["mono_chrome"])
                        super().__init__(service, version, mode, path)
                    class color(TUIMethod):
                        """
                        Plot hardcopies in color.
                        """
                    class gray_scale(TUIMethod):
                        """
                        Convert color to grayscale for hardcopy.
                        """
                    class list(TUIMethod):
                        """
                        Display the current hardcopy color mode.
                        """
                    class mono_chrome(TUIMethod):
                        """
                        Convert color to monochrome (black and white) for hardcopy.
                        """

                class driver(TUIMenu):
                    """
                    Enter the set hardcopy driver menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.post_format = self.__class__.post_format(service, version, mode, path + ["post_format"])
                        self.avz = self.__class__.avz(service, version, mode, path + ["avz"])
                        self.dump_window = self.__class__.dump_window(service, version, mode, path + ["dump_window"])
                        self.eps = self.__class__.eps(service, version, mode, path + ["eps"])
                        self.glb = self.__class__.glb(service, version, mode, path + ["glb"])
                        self.hsf = self.__class__.hsf(service, version, mode, path + ["hsf"])
                        self.jpeg = self.__class__.jpeg(service, version, mode, path + ["jpeg"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.options = self.__class__.options(service, version, mode, path + ["options"])
                        self.png = self.__class__.png(service, version, mode, path + ["png"])
                        self.post_script = self.__class__.post_script(service, version, mode, path + ["post_script"])
                        self.ppm = self.__class__.ppm(service, version, mode, path + ["ppm"])
                        self.tiff = self.__class__.tiff(service, version, mode, path + ["tiff"])
                        self.vrml = self.__class__.vrml(service, version, mode, path + ["vrml"])
                        super().__init__(service, version, mode, path)
                    class avz(TUIMethod):
                        """
                        Use AVZ output for hardcopies.
                        """
                    class dump_window(TUIMethod):
                        """
                        Set the command used to dump the graphics window to a file.
                        """
                    class eps(TUIMethod):
                        """
                        Produce encapsulated PostScript (EPS) output for hardcopies.
                        """
                    class glb(TUIMethod):
                        """
                        Use GLB output for hardcopies.
                        """
                    class hsf(TUIMethod):
                        """
                        Use HSF output for hardcopies.
                        """
                    class jpeg(TUIMethod):
                        """
                        Produce JPEG output for hardcopies.
                        """
                    class list(TUIMethod):
                        """
                        List the current hardcopy driver.
                        """
                    class options(TUIMethod):
                        """
                        Set the hardcopy options. Available options are:
                        "no gamma correction", disables gamma correction of colors,
                        "physical size = (width,height)", where width and height
                        are the actual measurements of the printable area of the page
                        in centimeters.
                        "subscreen = (left,right,bottom,top)", where left,right,
                        bottom, and top are numbers in [-1,1] describing a subwindow on
                        the page in which to place the hardcopy.
                        The options may be combined by separating them with commas.
                        """
                    class png(TUIMethod):
                        """
                        Use PNG output for hardcopies.
                        """
                    class post_script(TUIMethod):
                        """
                        Produce PostScript output for hardcopies.
                        """
                    class ppm(TUIMethod):
                        """
                        Produce PPM output for hardcopies.
                        """
                    class tiff(TUIMethod):
                        """
                        Use TIFF output for hardcopies.
                        """
                    class vrml(TUIMethod):
                        """
                        Use VRML output for hardcopies.
                        """

                    class post_format(TUIMenu):
                        """
                        Enter the PostScript driver format menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.fast_raster = self.__class__.fast_raster(service, version, mode, path + ["fast_raster"])
                            self.raster = self.__class__.raster(service, version, mode, path + ["raster"])
                            self.rle_raster = self.__class__.rle_raster(service, version, mode, path + ["rle_raster"])
                            self.vector = self.__class__.vector(service, version, mode, path + ["vector"])
                            super().__init__(service, version, mode, path)
                        class fast_raster(TUIMethod):
                            """
                            Use the new raster format.
                            """
                        class raster(TUIMethod):
                            """
                            Use the original raster format.
                            """
                        class rle_raster(TUIMethod):
                            """
                            Use the run-length encoded raster format.
                            """
                        class vector(TUIMethod):
                            """
                            Use vector format.
                            """

            class rendering_options(TUIMenu):
                """
                Enter the rendering options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.animation_option = self.__class__.animation_option(service, version, mode, path + ["animation_option"])
                    self.auto_spin = self.__class__.auto_spin(service, version, mode, path + ["auto_spin"])
                    self.color_map_alignment = self.__class__.color_map_alignment(service, version, mode, path + ["color_map_alignment"])
                    self.device_info = self.__class__.device_info(service, version, mode, path + ["device_info"])
                    self.double_buffering = self.__class__.double_buffering(service, version, mode, path + ["double_buffering"])
                    self.driver = self.__class__.driver(service, version, mode, path + ["driver"])
                    self.face_displacement = self.__class__.face_displacement(service, version, mode, path + ["face_displacement"])
                    self.front_faces_transparent = self.__class__.front_faces_transparent(service, version, mode, path + ["front_faces_transparent"])
                    self.help_text_color = self.__class__.help_text_color(service, version, mode, path + ["help_text_color"])
                    self.hidden_line_method = self.__class__.hidden_line_method(service, version, mode, path + ["hidden_line_method"])
                    self.hidden_lines = self.__class__.hidden_lines(service, version, mode, path + ["hidden_lines"])
                    self.hidden_surface_method = self.__class__.hidden_surface_method(service, version, mode, path + ["hidden_surface_method"])
                    self.hidden_surfaces = self.__class__.hidden_surfaces(service, version, mode, path + ["hidden_surfaces"])
                    self.set_rendering_options = self.__class__.set_rendering_options(service, version, mode, path + ["set_rendering_options"])
                    self.show_colormap = self.__class__.show_colormap(service, version, mode, path + ["show_colormap"])
                    self.surface_edge_visibility = self.__class__.surface_edge_visibility(service, version, mode, path + ["surface_edge_visibility"])
                    super().__init__(service, version, mode, path)
                class animation_option(TUIMethod):
                    """
                    Using Wireframe / All option during animation.
                    """
                class auto_spin(TUIMethod):
                    """
                    Enable/disable mouse view rotations to continue to spin the display after the button is released.
                    """
                class color_map_alignment(TUIMethod):
                    """
                    Set the color bar alignment.
                    """
                class device_info(TUIMethod):
                    """
                    List information for the graphics device.
                    """
                class double_buffering(TUIMethod):
                    """
                    Enable/disable double-buffering.
                    """
                class driver(TUIMethod):
                    """
                    Change the current graphics driver.
                    """
                class face_displacement(TUIMethod):
                    """
                    Set face displacement value in Z-buffer units along the Camera Z-axis.
                    """
                class front_faces_transparent(TUIMethod):
                    """
                    Make the front faces transparent.
                    """
                class help_text_color(TUIMethod):
                    """
                    Set the color of screen help text.
                    """
                class hidden_line_method(TUIMethod):
                    """
                    Specify the method to perform hidden line rendering.
                    """
                class hidden_lines(TUIMethod):
                    """
                    Enable/disable hidden line removal.
                    """
                class hidden_surface_method(TUIMethod):
                    """
                    Specify the method to perform hidden line and hidden surface rendering.
                    """
                class hidden_surfaces(TUIMethod):
                    """
                    Enable/disable hidden surface removal.
                    """
                class set_rendering_options(TUIMethod):
                    """
                    Set the rendering options.
                    """
                class show_colormap(TUIMethod):
                    """
                    Enable/Disable colormap.
                    """
                class surface_edge_visibility(TUIMethod):
                    """
                    Set edge visibility flags for surfaces.
                    """

            class titles(TUIMenu):
                """
                Set problem title.
                """
                def __init__(self, service, version, mode, path):
                    self.left_bottom = self.__class__.left_bottom(service, version, mode, path + ["left_bottom"])
                    self.left_top = self.__class__.left_top(service, version, mode, path + ["left_top"])
                    self.right_bottom = self.__class__.right_bottom(service, version, mode, path + ["right_bottom"])
                    self.right_middle = self.__class__.right_middle(service, version, mode, path + ["right_middle"])
                    self.right_top = self.__class__.right_top(service, version, mode, path + ["right_top"])
                    super().__init__(service, version, mode, path)
                class left_bottom(TUIMethod):
                    """
                    Set the title text for left bottom in title segment.
                    """
                class left_top(TUIMethod):
                    """
                    Set the title text for left top in title segment.
                    """
                class right_bottom(TUIMethod):
                    """
                    Set the title text for right bottom in title segment.
                    """
                class right_middle(TUIMethod):
                    """
                    Set the title text for right middle in title segment.
                    """
                class right_top(TUIMethod):
                    """
                    Set the title text for right top in title segment.
                    """

            class velocity_vectors(TUIMenu):
                """
                Enter the menu to set parameters for display of velocity vectors.
                """
                def __init__(self, service, version, mode, path):
                    self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
                    self.color = self.__class__.color(service, version, mode, path + ["color"])
                    self.color_levels = self.__class__.color_levels(service, version, mode, path + ["color_levels"])
                    self.component_x = self.__class__.component_x(service, version, mode, path + ["component_x"])
                    self.component_y = self.__class__.component_y(service, version, mode, path + ["component_y"])
                    self.component_z = self.__class__.component_z(service, version, mode, path + ["component_z"])
                    self.constant_length = self.__class__.constant_length(service, version, mode, path + ["constant_length"])
                    self.global_range = self.__class__.global_range(service, version, mode, path + ["global_range"])
                    self.in_plane = self.__class__.in_plane(service, version, mode, path + ["in_plane"])
                    self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                    self.node_values = self.__class__.node_values(service, version, mode, path + ["node_values"])
                    self.relative = self.__class__.relative(service, version, mode, path + ["relative"])
                    self.render_mesh = self.__class__.render_mesh(service, version, mode, path + ["render_mesh"])
                    self.scale = self.__class__.scale(service, version, mode, path + ["scale"])
                    self.scale_head = self.__class__.scale_head(service, version, mode, path + ["scale_head"])
                    self.style = self.__class__.style(service, version, mode, path + ["style"])
                    self.surfaces = self.__class__.surfaces(service, version, mode, path + ["surfaces"])
                    super().__init__(service, version, mode, path)
                class auto_scale(TUIMethod):
                    """
                    Enable/disable auto-scale of all vectors so that vector overlap is minimal.
                    """
                class color(TUIMethod):
                    """
                    Set the color used for all vectors. Set color to the null string to use the color map.
                    """
                class color_levels(TUIMethod):
                    """
                    Set the number of colors used from the color map.
                    """
                class component_x(TUIMethod):
                    """
                    Enable/disable use of x-component of vectors.
                    """
                class component_y(TUIMethod):
                    """
                    Enable/disable use of y-component of vectors.
                    """
                class component_z(TUIMethod):
                    """
                    Enable/disable use of z-component of vectors.
                    """
                class constant_length(TUIMethod):
                    """
                    Enable/disable setting all vectors to have the same length.
                    """
                class global_range(TUIMethod):
                    """
                    Enable/disable the global range for vectors option.
                    """
                class in_plane(TUIMethod):
                    """
                    Toggle the display of in-plane velocity vectors.
                    """
                class log_scale(TUIMethod):
                    """
                    Enable/disable the use of a log scale.
                    """
                class node_values(TUIMethod):
                    """
                    Enable/disable plotting node values. Cell values will be plotted if "no".
                    """
                class relative(TUIMethod):
                    """
                    Enable/disable the display of relative velocity vectors.
                    """
                class render_mesh(TUIMethod):
                    """
                    Enable/disable rendering the mseh on top of contours, vectors, etc.
                    """
                class scale(TUIMethod):
                    """
                    Set the value by which the vector length will be scaled.
                    """
                class scale_head(TUIMethod):
                    """
                    Set the value by which the vector head will be scaled.
                    """
                class style(TUIMethod):
                    """
                    Set the style with which the vectors will be drawn.
                    """
                class surfaces(TUIMethod):
                    """
                    Set surfaces on which vectors are drawn.
                    """

            class windows(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.main = self.__class__.main(service, version, mode, path + ["main"])
                    self.scale = self.__class__.scale(service, version, mode, path + ["scale"])
                    self.text = self.__class__.text(service, version, mode, path + ["text"])
                    self.video = self.__class__.video(service, version, mode, path + ["video"])
                    self.xy = self.__class__.xy(service, version, mode, path + ["xy"])
                    self.aspect_ratio = self.__class__.aspect_ratio(service, version, mode, path + ["aspect_ratio"])
                    self.close_window = self.__class__.close_window(service, version, mode, path + ["close_window"])
                    self.close_window_by_name = self.__class__.close_window_by_name(service, version, mode, path + ["close_window_by_name"])
                    self.logo = self.__class__.logo(service, version, mode, path + ["logo"])
                    self.logo_color = self.__class__.logo_color(service, version, mode, path + ["logo_color"])
                    self.open_window = self.__class__.open_window(service, version, mode, path + ["open_window"])
                    self.ruler = self.__class__.ruler(service, version, mode, path + ["ruler"])
                    self.set_window = self.__class__.set_window(service, version, mode, path + ["set_window"])
                    self.set_window_by_name = self.__class__.set_window_by_name(service, version, mode, path + ["set_window_by_name"])
                    super().__init__(service, version, mode, path)
                class aspect_ratio(TUIMethod):
                    """
                    .
                    """
                class close_window(TUIMethod):
                    """
                    .
                    """
                class close_window_by_name(TUIMethod):
                    """
                    .
                    """
                class logo(TUIMethod):
                    """
                    .
                    """
                class logo_color(TUIMethod):
                    """
                    .
                    """
                class open_window(TUIMethod):
                    """
                    .
                    """
                class ruler(TUIMethod):
                    """
                    .
                    """
                class set_window(TUIMethod):
                    """
                    .
                    """
                class set_window_by_name(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.clear = self.__class__.clear(service, version, mode, path + ["clear"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class clear(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

                class main(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

                class scale(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.clear = self.__class__.clear(service, version, mode, path + ["clear"])
                        self.font_size = self.__class__.font_size(service, version, mode, path + ["font_size"])
                        self.format = self.__class__.format(service, version, mode, path + ["format"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.margin = self.__class__.margin(service, version, mode, path + ["margin"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class clear(TUIMethod):
                        """
                        .
                        """
                    class font_size(TUIMethod):
                        """
                        .
                        """
                    class format(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class margin(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

                class text(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.alignment = self.__class__.alignment(service, version, mode, path + ["alignment"])
                        self.application = self.__class__.application(service, version, mode, path + ["application"])
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.clear = self.__class__.clear(service, version, mode, path + ["clear"])
                        self.company = self.__class__.company(service, version, mode, path + ["company"])
                        self.date = self.__class__.date(service, version, mode, path + ["date"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class alignment(TUIMethod):
                        """
                        .
                        """
                    class application(TUIMethod):
                        """
                        .
                        """
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class clear(TUIMethod):
                        """
                        .
                        """
                    class company(TUIMethod):
                        """
                        .
                        """
                    class date(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

                class video(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.background = self.__class__.background(service, version, mode, path + ["background"])
                        self.color_filter = self.__class__.color_filter(service, version, mode, path + ["color_filter"])
                        self.foreground = self.__class__.foreground(service, version, mode, path + ["foreground"])
                        self.on = self.__class__.on(service, version, mode, path + ["on"])
                        self.pixel_size = self.__class__.pixel_size(service, version, mode, path + ["pixel_size"])
                        super().__init__(service, version, mode, path)
                    class background(TUIMethod):
                        """
                        .
                        """
                    class color_filter(TUIMethod):
                        """
                        .
                        """
                    class foreground(TUIMethod):
                        """
                        .
                        """
                    class on(TUIMethod):
                        """
                        .
                        """
                    class pixel_size(TUIMethod):
                        """
                        .
                        """

                class xy(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

        class surface(TUIMenu):
            """
            Enter the data surface manipulation menu.
            """
            def __init__(self, service, version, mode, path):
                self.post_processing_volume = self.__class__.post_processing_volume(service, version, mode, path + ["post_processing_volume"])
                self.query = self.__class__.query(service, version, mode, path + ["query"])
                self.circle_slice = self.__class__.circle_slice(service, version, mode, path + ["circle_slice"])
                self.closest_point_search = self.__class__.closest_point_search(service, version, mode, path + ["closest_point_search"])
                self.cone_slice = self.__class__.cone_slice(service, version, mode, path + ["cone_slice"])
                self.create_imprint_surface = self.__class__.create_imprint_surface(service, version, mode, path + ["create_imprint_surface"])
                self.delete_surface = self.__class__.delete_surface(service, version, mode, path + ["delete_surface"])
                self.edit_surface = self.__class__.edit_surface(service, version, mode, path + ["edit_surface"])
                self.ellipsoid_slice = self.__class__.ellipsoid_slice(service, version, mode, path + ["ellipsoid_slice"])
                self.expression_volume = self.__class__.expression_volume(service, version, mode, path + ["expression_volume"])
                self.group_surfaces = self.__class__.group_surfaces(service, version, mode, path + ["group_surfaces"])
                self.import_surface = self.__class__.import_surface(service, version, mode, path + ["import_surface"])
                self.imprint_surface = self.__class__.imprint_surface(service, version, mode, path + ["imprint_surface"])
                self.iso_clip = self.__class__.iso_clip(service, version, mode, path + ["iso_clip"])
                self.iso_clip_multiple = self.__class__.iso_clip_multiple(service, version, mode, path + ["iso_clip_multiple"])
                self.iso_surface = self.__class__.iso_surface(service, version, mode, path + ["iso_surface"])
                self.line_slice = self.__class__.line_slice(service, version, mode, path + ["line_slice"])
                self.line_surface = self.__class__.line_surface(service, version, mode, path + ["line_surface"])
                self.list_surfaces = self.__class__.list_surfaces(service, version, mode, path + ["list_surfaces"])
                self.mouse_line = self.__class__.mouse_line(service, version, mode, path + ["mouse_line"])
                self.mouse_plane = self.__class__.mouse_plane(service, version, mode, path + ["mouse_plane"])
                self.mouse_rake = self.__class__.mouse_rake(service, version, mode, path + ["mouse_rake"])
                self.multiple_iso_surfaces = self.__class__.multiple_iso_surfaces(service, version, mode, path + ["multiple_iso_surfaces"])
                self.multiple_plane_surfaces = self.__class__.multiple_plane_surfaces(service, version, mode, path + ["multiple_plane_surfaces"])
                self.multiple_zone_surfaces = self.__class__.multiple_zone_surfaces(service, version, mode, path + ["multiple_zone_surfaces"])
                self.partition_surface = self.__class__.partition_surface(service, version, mode, path + ["partition_surface"])
                self.plane = self.__class__.plane(service, version, mode, path + ["plane"])
                self.plane_bounded = self.__class__.plane_bounded(service, version, mode, path + ["plane_bounded"])
                self.plane_point_n_normal = self.__class__.plane_point_n_normal(service, version, mode, path + ["plane_point_n_normal"])
                self.plane_slice = self.__class__.plane_slice(service, version, mode, path + ["plane_slice"])
                self.plane_surf_aligned = self.__class__.plane_surf_aligned(service, version, mode, path + ["plane_surf_aligned"])
                self.plane_surface = self.__class__.plane_surface(service, version, mode, path + ["plane_surface"])
                self.plane_view_plane_align = self.__class__.plane_view_plane_align(service, version, mode, path + ["plane_view_plane_align"])
                self.point_array = self.__class__.point_array(service, version, mode, path + ["point_array"])
                self.point_surface = self.__class__.point_surface(service, version, mode, path + ["point_surface"])
                self.quadric_slice = self.__class__.quadric_slice(service, version, mode, path + ["quadric_slice"])
                self.rake_surface = self.__class__.rake_surface(service, version, mode, path + ["rake_surface"])
                self.rename_surface = self.__class__.rename_surface(service, version, mode, path + ["rename_surface"])
                self.rendering_priority = self.__class__.rendering_priority(service, version, mode, path + ["rendering_priority"])
                self.reset_zone_surfaces = self.__class__.reset_zone_surfaces(service, version, mode, path + ["reset_zone_surfaces"])
                self.sphere_slice = self.__class__.sphere_slice(service, version, mode, path + ["sphere_slice"])
                self.split_surface = self.__class__.split_surface(service, version, mode, path + ["split_surface"])
                self.structural_point_surface = self.__class__.structural_point_surface(service, version, mode, path + ["structural_point_surface"])
                self.surface_cells = self.__class__.surface_cells(service, version, mode, path + ["surface_cells"])
                self.transform_surface = self.__class__.transform_surface(service, version, mode, path + ["transform_surface"])
                self.ungroup_surface = self.__class__.ungroup_surface(service, version, mode, path + ["ungroup_surface"])
                self.zone_surface = self.__class__.zone_surface(service, version, mode, path + ["zone_surface"])
                super().__init__(service, version, mode, path)
            class circle_slice(TUIMethod):
                """
                Extract a circular slice.
                """
            class closest_point_search(TUIMethod):
                """
                Enable the point surface algorithm to look for the nearest point instead of reporting a creation failure.
                """
            class cone_slice(TUIMethod):
                """
                Extract a cone slice.
                """
            class create_imprint_surface(TUIMethod):
                """
                Imprint surface.
                """
            class delete_surface(TUIMethod):
                """
                Remove a defined data surface.
                """
            class edit_surface(TUIMethod):
                """
                Edit a defined data surface.
                """
            class ellipsoid_slice(TUIMethod):
                """
                Extract a ellipsoid slice.
                """
            class expression_volume(TUIMethod):
                """
                Create volume with boolean expression.
                """
            class group_surfaces(TUIMethod):
                """
                Group a set of surfaces.
                """
            class import_surface(TUIMethod):
                """
                Import surface.
                """
            class imprint_surface(TUIMethod):
                """
                Imprint surface.
                """
            class iso_clip(TUIMethod):
                """
                Clip a data surface (surface, curve, or point) between two iso-values.
                """
            class iso_clip_multiple(TUIMethod):
                """
                Clip a data surface (surface, curve, or point) between two iso-values.
                """
            class iso_surface(TUIMethod):
                """
                Extract an iso-surface (surface, curve, or point) from the curent data field.
                """
            class line_slice(TUIMethod):
                """
                Extract a linear slice.
                """
            class line_surface(TUIMethod):
                """
                Define a "line" surface by specifying the two endpoint coordinates.
                """
            class list_surfaces(TUIMethod):
                """
                List the number of facets in the defined surfaces.
                """
            class mouse_line(TUIMethod):
                """
                Define a line surface using the mouse to select two points.
                """
            class mouse_plane(TUIMethod):
                """
                Define a plane surface using the mouse to select three points.
                """
            class mouse_rake(TUIMethod):
                """
                Define a "rake" surface using the mouse to select the end points.
                """
            class multiple_iso_surfaces(TUIMethod):
                """
                .
                """
            class multiple_plane_surfaces(TUIMethod):
                """
                .
                """
            class multiple_zone_surfaces(TUIMethod):
                """
                Create multiple data surfaces at a time.
                """
            class partition_surface(TUIMethod):
                """
                Define a data surface on mesh faces on the partition boundary.
                """
            class plane(TUIMethod):
                """
                Create a plane given 3 points bounded by the domain.
                """
            class plane_bounded(TUIMethod):
                """
                Create a bounded surface.
                """
            class plane_point_n_normal(TUIMethod):
                """
                Create a plane from a point and normal.
                """
            class plane_slice(TUIMethod):
                """
                Extract a planar slice.
                """
            class plane_surf_aligned(TUIMethod):
                """
                Create a plane aligned to a surface.
                """
            class plane_surface(TUIMethod):
                """
                Create a plane from a coordinate plane, point and normal, or three points.
                """
            class plane_view_plane_align(TUIMethod):
                """
                Create a plane aligned to a view-plane.
                """
            class point_array(TUIMethod):
                """
                Extract a rectangular array of data points.
                """
            class point_surface(TUIMethod):
                """
                Define a "point" surface by specifying the coordinates.
                """
            class quadric_slice(TUIMethod):
                """
                Extract a quadric slice.
                """
            class rake_surface(TUIMethod):
                """
                Define a "rake" surface by specifying the end points.
                """
            class rename_surface(TUIMethod):
                """
                Rename a defined data surface.
                """
            class rendering_priority(TUIMethod):
                """
                Define Priority for given surface id.
                """
            class reset_zone_surfaces(TUIMethod):
                """
                .
                """
            class sphere_slice(TUIMethod):
                """
                Extract a spherical slice.
                """
            class split_surface(TUIMethod):
                """
                Split Surface.
                """
            class structural_point_surface(TUIMethod):
                """
                Define a "structural point" surface by specifying the coordinates.
                """
            class surface_cells(TUIMethod):
                """
                Extract all cells intersected by a data surface.
                """
            class transform_surface(TUIMethod):
                """
                Transform surface.
                """
            class ungroup_surface(TUIMethod):
                """
                Ungroup the surface(if grouped).
                """
            class zone_surface(TUIMethod):
                """
                Define a data surface on a mesh zone.
                """

            class post_processing_volume(TUIMenu):
                """
                Enter post-processing volume menu.
                """
                def __init__(self, service, version, mode, path):
                    self.create_from_file = self.__class__.create_from_file(service, version, mode, path + ["create_from_file"])
                    self.create_octree = self.__class__.create_octree(service, version, mode, path + ["create_octree"])
                    super().__init__(service, version, mode, path)
                class create_from_file(TUIMethod):
                    """
                    Read post-processing mesh from file.
                    """
                class create_octree(TUIMethod):
                    """
                    Create post-processing octree mesh based on current case.
                    """

            class query(TUIMenu):
                """
                Enter surface query menu.
                """
                def __init__(self, service, version, mode, path):
                    self.delete_query = self.__class__.delete_query(service, version, mode, path + ["delete_query"])
                    self.list_named_selection = self.__class__.list_named_selection(service, version, mode, path + ["list_named_selection"])
                    self.list_queries = self.__class__.list_queries(service, version, mode, path + ["list_queries"])
                    self.list_surfaces = self.__class__.list_surfaces(service, version, mode, path + ["list_surfaces"])
                    self.named_surface_list = self.__class__.named_surface_list(service, version, mode, path + ["named_surface_list"])
                    super().__init__(service, version, mode, path)
                class delete_query(TUIMethod):
                    """
                    Delete saved query.
                    """
                class list_named_selection(TUIMethod):
                    """
                    List named selection of surface type.
                    """
                class list_queries(TUIMethod):
                    """
                    List all saved queries.
                    """
                class list_surfaces(TUIMethod):
                    """
                    List surfaces.
                    """
                class named_surface_list(TUIMethod):
                    """
                    Create named list of surfaces.
                    """

        class update_scene(TUIMenu):
            """
            Enter the scene options menu.
            """
            def __init__(self, service, version, mode, path):
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.draw_frame = self.__class__.draw_frame(service, version, mode, path + ["draw_frame"])
                self.iso_sweep = self.__class__.iso_sweep(service, version, mode, path + ["iso_sweep"])
                self.overlays = self.__class__.overlays(service, version, mode, path + ["overlays"])
                self.pathline = self.__class__.pathline(service, version, mode, path + ["pathline"])
                self.select_geometry = self.__class__.select_geometry(service, version, mode, path + ["select_geometry"])
                self.set_frame = self.__class__.set_frame(service, version, mode, path + ["set_frame"])
                self.time = self.__class__.time(service, version, mode, path + ["time"])
                self.transform = self.__class__.transform(service, version, mode, path + ["transform"])
                super().__init__(service, version, mode, path)
            class delete(TUIMethod):
                """
                Delete selected geometries.
                """
            class display(TUIMethod):
                """
                Display selected geometries.
                """
            class draw_frame(TUIMethod):
                """
                Enable/disable drawing of the bounding frame.
                """
            class iso_sweep(TUIMethod):
                """
                Change iso-sweep values.
                """
            class overlays(TUIMethod):
                """
                Enable/disable the overlays option.
                """
            class pathline(TUIMethod):
                """
                Change pathline attributes.
                """
            class select_geometry(TUIMethod):
                """
                Select geometry to be updated.
                """
            class set_frame(TUIMethod):
                """
                Change frame options.
                """
            class time(TUIMethod):
                """
                Change time-step value.
                """
            class transform(TUIMethod):
                """
                Apply transformation matrix on selected geometries.
                """

        class view_sync(TUIMenu):
            """
            Synchronize window views.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.add_all = self.__class__.add_all(service, version, mode, path + ["add_all"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.remove = self.__class__.remove(service, version, mode, path + ["remove"])
                self.remove_all = self.__class__.remove_all(service, version, mode, path + ["remove_all"])
                self.start = self.__class__.start(service, version, mode, path + ["start"])
                self.stop = self.__class__.stop(service, version, mode, path + ["stop"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add list of window ids for synchronization.
                """
            class add_all(TUIMethod):
                """
                Synchronize all windows.
                """
            class list(TUIMethod):
                """
                Print window ids of open windows.
                """
            class remove(TUIMethod):
                """
                Remove list of window ids from synchronization.
                """
            class remove_all(TUIMethod):
                """
                Unsynchronize all windows.
                """
            class start(TUIMethod):
                """
                Start view synchronization.
                """
            class stop(TUIMethod):
                """
                Stop view synchronization.
                """

        class views(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.camera = self.__class__.camera(service, version, mode, path + ["camera"])
                self.display_states = self.__class__.display_states(service, version, mode, path + ["display_states"])
                self.mirror_planes = self.__class__.mirror_planes(service, version, mode, path + ["mirror_planes"])
                self.rendering_options = self.__class__.rendering_options(service, version, mode, path + ["rendering_options"])
                self.apply_mirror_planes = self.__class__.apply_mirror_planes(service, version, mode, path + ["apply_mirror_planes"])
                self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
                self.default_view = self.__class__.default_view(service, version, mode, path + ["default_view"])
                self.delete_view = self.__class__.delete_view(service, version, mode, path + ["delete_view"])
                self.last_view = self.__class__.last_view(service, version, mode, path + ["last_view"])
                self.list_views = self.__class__.list_views(service, version, mode, path + ["list_views"])
                self.mirror_zones = self.__class__.mirror_zones(service, version, mode, path + ["mirror_zones"])
                self.next_view = self.__class__.next_view(service, version, mode, path + ["next_view"])
                self.read_views = self.__class__.read_views(service, version, mode, path + ["read_views"])
                self.restore_view = self.__class__.restore_view(service, version, mode, path + ["restore_view"])
                self.save_view = self.__class__.save_view(service, version, mode, path + ["save_view"])
                self.write_views = self.__class__.write_views(service, version, mode, path + ["write_views"])
                super().__init__(service, version, mode, path)
            class apply_mirror_planes(TUIMethod):
                """
                .
                """
            class auto_scale(TUIMethod):
                """
                .
                """
            class default_view(TUIMethod):
                """
                .
                """
            class delete_view(TUIMethod):
                """
                .
                """
            class last_view(TUIMethod):
                """
                .
                """
            class list_views(TUIMethod):
                """
                .
                """
            class mirror_zones(TUIMethod):
                """
                .
                """
            class next_view(TUIMethod):
                """
                .
                """
            class read_views(TUIMethod):
                """
                .
                """
            class restore_view(TUIMethod):
                """
                .
                """
            class save_view(TUIMethod):
                """
                .
                """
            class write_views(TUIMethod):
                """
                .
                """

            class camera(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.dolly_camera = self.__class__.dolly_camera(service, version, mode, path + ["dolly_camera"])
                    self.field = self.__class__.field(service, version, mode, path + ["field"])
                    self.orbit_camera = self.__class__.orbit_camera(service, version, mode, path + ["orbit_camera"])
                    self.pan_camera = self.__class__.pan_camera(service, version, mode, path + ["pan_camera"])
                    self.position = self.__class__.position(service, version, mode, path + ["position"])
                    self.projection = self.__class__.projection(service, version, mode, path + ["projection"])
                    self.roll_camera = self.__class__.roll_camera(service, version, mode, path + ["roll_camera"])
                    self.target = self.__class__.target(service, version, mode, path + ["target"])
                    self.up_vector = self.__class__.up_vector(service, version, mode, path + ["up_vector"])
                    self.zoom_camera = self.__class__.zoom_camera(service, version, mode, path + ["zoom_camera"])
                    super().__init__(service, version, mode, path)
                class dolly_camera(TUIMethod):
                    """
                    .
                    """
                class field(TUIMethod):
                    """
                    .
                    """
                class orbit_camera(TUIMethod):
                    """
                    .
                    """
                class pan_camera(TUIMethod):
                    """
                    .
                    """
                class position(TUIMethod):
                    """
                    .
                    """
                class projection(TUIMethod):
                    """
                    .
                    """
                class roll_camera(TUIMethod):
                    """
                    .
                    """
                class target(TUIMethod):
                    """
                    .
                    """
                class up_vector(TUIMethod):
                    """
                    .
                    """
                class zoom_camera(TUIMethod):
                    """
                    .
                    """

            class display_states(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.new = self.__class__.new(service, version, mode, path + ["new"])
                    self.read = self.__class__.read(service, version, mode, path + ["read"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    self.restore_state = self.__class__.restore_state(service, version, mode, path + ["restore_state"])
                    self.use_active = self.__class__.use_active(service, version, mode, path + ["use_active"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    super().__init__(service, version, mode, path)
                class copy(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit display-states object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class new(TUIMethod):
                    """
                    Create a new display-states object.
                    """
                class read(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """
                class restore_state(TUIMethod):
                    """
                    .
                    """
                class use_active(TUIMethod):
                    """
                    .
                    """
                class write(TUIMethod):
                    """
                    .
                    """

            class mirror_planes(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.new = self.__class__.new(service, version, mode, path + ["new"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit mirror-planes object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class new(TUIMethod):
                    """
                    Create a new mirror-planes object.
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class rendering_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.animation_option = self.__class__.animation_option(service, version, mode, path + ["animation_option"])
                    self.auto_spin = self.__class__.auto_spin(service, version, mode, path + ["auto_spin"])
                    self.color_map_alignment = self.__class__.color_map_alignment(service, version, mode, path + ["color_map_alignment"])
                    self.device_info = self.__class__.device_info(service, version, mode, path + ["device_info"])
                    self.double_buffering = self.__class__.double_buffering(service, version, mode, path + ["double_buffering"])
                    self.driver = self.__class__.driver(service, version, mode, path + ["driver"])
                    self.face_displacement = self.__class__.face_displacement(service, version, mode, path + ["face_displacement"])
                    self.front_faces_transparent = self.__class__.front_faces_transparent(service, version, mode, path + ["front_faces_transparent"])
                    self.hidden_surface_method = self.__class__.hidden_surface_method(service, version, mode, path + ["hidden_surface_method"])
                    self.hidden_surfaces = self.__class__.hidden_surfaces(service, version, mode, path + ["hidden_surfaces"])
                    self.set_rendering_options = self.__class__.set_rendering_options(service, version, mode, path + ["set_rendering_options"])
                    self.show_colormap = self.__class__.show_colormap(service, version, mode, path + ["show_colormap"])
                    super().__init__(service, version, mode, path)
                class animation_option(TUIMethod):
                    """
                    .
                    """
                class auto_spin(TUIMethod):
                    """
                    .
                    """
                class color_map_alignment(TUIMethod):
                    """
                    .
                    """
                class device_info(TUIMethod):
                    """
                    .
                    """
                class double_buffering(TUIMethod):
                    """
                    .
                    """
                class driver(TUIMethod):
                    """
                    .
                    """
                class face_displacement(TUIMethod):
                    """
                    .
                    """
                class front_faces_transparent(TUIMethod):
                    """
                    .
                    """
                class hidden_surface_method(TUIMethod):
                    """
                    .
                    """
                class hidden_surfaces(TUIMethod):
                    """
                    .
                    """
                class set_rendering_options(TUIMethod):
                    """
                    .
                    """
                class show_colormap(TUIMethod):
                    """
                    .
                    """

    class file(TUIMenu):
        """
        Enter the file menu.
        """
        def __init__(self, service, version, mode, path):
            self.auto_save = self.__class__.auto_save(service, version, mode, path + ["auto_save"])
            self.cffio_options = self.__class__.cffio_options(service, version, mode, path + ["cffio_options"])
            self.em_mapping = self.__class__.em_mapping(service, version, mode, path + ["em_mapping"])
            self.export = self.__class__.export(service, version, mode, path + ["export"])
            self.fsi = self.__class__.fsi(service, version, mode, path + ["fsi"])
            self.import_ = self.__class__.import_(service, version, mode, path + ["import_"])
            self.interpolate = self.__class__.interpolate(service, version, mode, path + ["interpolate"])
            self.parametric_project = self.__class__.parametric_project(service, version, mode, path + ["parametric_project"])
            self.project_beta = self.__class__.project_beta(service, version, mode, path + ["project_beta"])
            self.solution_files = self.__class__.solution_files(service, version, mode, path + ["solution_files"])
            self.table_manager = self.__class__.table_manager(service, version, mode, path + ["table_manager"])
            self.transient_export = self.__class__.transient_export(service, version, mode, path + ["transient_export"])
            self.async_optimize = self.__class__.async_optimize(service, version, mode, path + ["async_optimize"])
            self.auto_merge_zones = self.__class__.auto_merge_zones(service, version, mode, path + ["auto_merge_zones"])
            self.binary_legacy_files = self.__class__.binary_legacy_files(service, version, mode, path + ["binary_legacy_files"])
            self.cff_files = self.__class__.cff_files(service, version, mode, path + ["cff_files"])
            self.close_without_save = self.__class__.close_without_save(service, version, mode, path + ["close_without_save"])
            self.confirm_overwrite = self.__class__.confirm_overwrite(service, version, mode, path + ["confirm_overwrite"])
            self.convert_hanging_nodes_during_read = self.__class__.convert_hanging_nodes_during_read(service, version, mode, path + ["convert_hanging_nodes_during_read"])
            self.data_file_options = self.__class__.data_file_options(service, version, mode, path + ["data_file_options"])
            self.define_macro = self.__class__.define_macro(service, version, mode, path + ["define_macro"])
            self.execute_macro = self.__class__.execute_macro(service, version, mode, path + ["execute_macro"])
            self.export_to_cfd_post = self.__class__.export_to_cfd_post(service, version, mode, path + ["export_to_cfd_post"])
            self.load_act_tool = self.__class__.load_act_tool(service, version, mode, path + ["load_act_tool"])
            self.read_case = self.__class__.read_case(service, version, mode, path + ["read_case"])
            self.read_case_data = self.__class__.read_case_data(service, version, mode, path + ["read_case_data"])
            self.read_case_info = self.__class__.read_case_info(service, version, mode, path + ["read_case_info"])
            self.read_case_settings = self.__class__.read_case_settings(service, version, mode, path + ["read_case_settings"])
            self.read_data = self.__class__.read_data(service, version, mode, path + ["read_data"])
            self.read_field_functions = self.__class__.read_field_functions(service, version, mode, path + ["read_field_functions"])
            self.read_injections = self.__class__.read_injections(service, version, mode, path + ["read_injections"])
            self.read_isat_table = self.__class__.read_isat_table(service, version, mode, path + ["read_isat_table"])
            self.read_journal = self.__class__.read_journal(service, version, mode, path + ["read_journal"])
            self.read_macros = self.__class__.read_macros(service, version, mode, path + ["read_macros"])
            self.read_pdf = self.__class__.read_pdf(service, version, mode, path + ["read_pdf"])
            self.read_profile = self.__class__.read_profile(service, version, mode, path + ["read_profile"])
            self.read_rays = self.__class__.read_rays(service, version, mode, path + ["read_rays"])
            self.read_settings = self.__class__.read_settings(service, version, mode, path + ["read_settings"])
            self.read_surface_clusters = self.__class__.read_surface_clusters(service, version, mode, path + ["read_surface_clusters"])
            self.read_transient_table = self.__class__.read_transient_table(service, version, mode, path + ["read_transient_table"])
            self.read_viewfactors = self.__class__.read_viewfactors(service, version, mode, path + ["read_viewfactors"])
            self.reload_setup = self.__class__.reload_setup(service, version, mode, path + ["reload_setup"])
            self.replace_mesh = self.__class__.replace_mesh(service, version, mode, path + ["replace_mesh"])
            self.set_batch_options = self.__class__.set_batch_options(service, version, mode, path + ["set_batch_options"])
            self.set_error_on_invalid_command = self.__class__.set_error_on_invalid_command(service, version, mode, path + ["set_error_on_invalid_command"])
            self.set_idle_timeout = self.__class__.set_idle_timeout(service, version, mode, path + ["set_idle_timeout"])
            self.set_maximum_simultaneous_files = self.__class__.set_maximum_simultaneous_files(service, version, mode, path + ["set_maximum_simultaneous_files"])
            self.set_target_reference_frame_for_write_profiles = self.__class__.set_target_reference_frame_for_write_profiles(service, version, mode, path + ["set_target_reference_frame_for_write_profiles"])
            self.set_tui_version = self.__class__.set_tui_version(service, version, mode, path + ["set_tui_version"])
            self.show_configuration = self.__class__.show_configuration(service, version, mode, path + ["show_configuration"])
            self.single_precision_coordinates = self.__class__.single_precision_coordinates(service, version, mode, path + ["single_precision_coordinates"])
            self.start_journal = self.__class__.start_journal(service, version, mode, path + ["start_journal"])
            self.start_transcript = self.__class__.start_transcript(service, version, mode, path + ["start_transcript"])
            self.stop_journal = self.__class__.stop_journal(service, version, mode, path + ["stop_journal"])
            self.stop_macro = self.__class__.stop_macro(service, version, mode, path + ["stop_macro"])
            self.stop_transcript = self.__class__.stop_transcript(service, version, mode, path + ["stop_transcript"])
            self.sync_workbench = self.__class__.sync_workbench(service, version, mode, path + ["sync_workbench"])
            self.write_boundary_mesh = self.__class__.write_boundary_mesh(service, version, mode, path + ["write_boundary_mesh"])
            self.write_case = self.__class__.write_case(service, version, mode, path + ["write_case"])
            self.write_case_data = self.__class__.write_case_data(service, version, mode, path + ["write_case_data"])
            self.write_circumferential_averaged_profile = self.__class__.write_circumferential_averaged_profile(service, version, mode, path + ["write_circumferential_averaged_profile"])
            self.write_cleanup_script = self.__class__.write_cleanup_script(service, version, mode, path + ["write_cleanup_script"])
            self.write_currently_defined_profiles = self.__class__.write_currently_defined_profiles(service, version, mode, path + ["write_currently_defined_profiles"])
            self.write_data = self.__class__.write_data(service, version, mode, path + ["write_data"])
            self.write_fan_profile = self.__class__.write_fan_profile(service, version, mode, path + ["write_fan_profile"])
            self.write_field_functions = self.__class__.write_field_functions(service, version, mode, path + ["write_field_functions"])
            self.write_flamelet = self.__class__.write_flamelet(service, version, mode, path + ["write_flamelet"])
            self.write_injections = self.__class__.write_injections(service, version, mode, path + ["write_injections"])
            self.write_isat_table = self.__class__.write_isat_table(service, version, mode, path + ["write_isat_table"])
            self.write_macros = self.__class__.write_macros(service, version, mode, path + ["write_macros"])
            self.write_merge_profiles = self.__class__.write_merge_profiles(service, version, mode, path + ["write_merge_profiles"])
            self.write_pdat = self.__class__.write_pdat(service, version, mode, path + ["write_pdat"])
            self.write_pdf = self.__class__.write_pdf(service, version, mode, path + ["write_pdf"])
            self.write_profile = self.__class__.write_profile(service, version, mode, path + ["write_profile"])
            self.write_selected_defined_profiles = self.__class__.write_selected_defined_profiles(service, version, mode, path + ["write_selected_defined_profiles"])
            self.write_settings = self.__class__.write_settings(service, version, mode, path + ["write_settings"])
            super().__init__(service, version, mode, path)
        class async_optimize(TUIMethod):
            """
            .
            """
        class auto_merge_zones(TUIMethod):
            """
            .
            """
        class binary_legacy_files(TUIMethod):
            """
            .
            """
        class cff_files(TUIMethod):
            """
            .
            """
        class close_without_save(TUIMethod):
            """
            Exit without save.
            """
        class confirm_overwrite(TUIMethod):
            """
            .
            """
        class convert_hanging_nodes_during_read(TUIMethod):
            """
            .
            """
        class data_file_options(TUIMethod):
            """
            Set derived quantities to be written in data file.
            """
        class define_macro(TUIMethod):
            """
            .
            """
        class execute_macro(TUIMethod):
            """
            .
            """
        class export_to_cfd_post(TUIMethod):
            """
            Export to CFD-Post compabitble data file.
            """
        class load_act_tool(TUIMethod):
            """
            Load ACT Start Page.
            """
        class read_case(TUIMethod):
            """
            Read a case file.
            """
        class read_case_data(TUIMethod):
            """
            Read a case and a data file.
            """
        class read_case_info(TUIMethod):
            """
            Read basic case info.
            """
        class read_case_settings(TUIMethod):
            """
            Read a case file while skipping mesh elements.
            """
        class read_data(TUIMethod):
            """
            Read a data file.
            """
        class read_field_functions(TUIMethod):
            """
            .
            """
        class read_injections(TUIMethod):
            """
            .
            """
        class read_isat_table(TUIMethod):
            """
            .
            """
        class read_journal(TUIMethod):
            """
            Read a journal file.
            """
        class read_macros(TUIMethod):
            """
            .
            """
        class read_pdf(TUIMethod):
            """
            .
            """
        class read_profile(TUIMethod):
            """
            Read boundary profile data (\\*.prof, \\*.csv). Default is \\*.prof.
            """
        class read_rays(TUIMethod):
            """
            Read a DTRM rays file.
            """
        class read_settings(TUIMethod):
            """
            .
            """
        class read_surface_clusters(TUIMethod):
            """
            Read an S2S file.
            """
        class read_transient_table(TUIMethod):
            """
            Read a table of transient boundary profile data.
            """
        class read_viewfactors(TUIMethod):
            """
            Read an S2S file.
            """
        class reload_setup(TUIMethod):
            """
            Reload case and settings from last saved state.
            """
        class replace_mesh(TUIMethod):
            """
            Replace the mesh with a new one while preserving settings.
            """
        class set_batch_options(TUIMethod):
            """
            Set the batch options.
            """
        class set_error_on_invalid_command(TUIMethod):
            """
            Set whether to abort journal replay on invalid command.
            """
        class set_idle_timeout(TUIMethod):
            """
            Set the idle timeout.
            """
        class set_maximum_simultaneous_files(TUIMethod):
            """
            Specify the maximum number of files, such as report files and profiles, that may be open or written simultaneously. If the number of working files exceeds this limit, files may not be written or Fluent may close unexpectedly.
            """
        class set_target_reference_frame_for_write_profiles(TUIMethod):
            """
            Set reference frame options, which will be used for position transformation during writing of profiles.
            """
        class set_tui_version(TUIMethod):
            """
            Set the version of the TUI commands.
            """
        class show_configuration(TUIMethod):
            """
            .
            """
        class single_precision_coordinates(TUIMethod):
            """
            .
            """
        class start_journal(TUIMethod):
            """
            .
            """
        class start_transcript(TUIMethod):
            """
            .
            """
        class stop_journal(TUIMethod):
            """
            .
            """
        class stop_macro(TUIMethod):
            """
            .
            """
        class stop_transcript(TUIMethod):
            """
            .
            """
        class sync_workbench(TUIMethod):
            """
            Sync Fluent changes with WorkBench.
            """
        class write_boundary_mesh(TUIMethod):
            """
            Write the boundary mesh to a file.
            """
        class write_case(TUIMethod):
            """
            Write a case file.
            """
        class write_case_data(TUIMethod):
            """
            Write a case and a data file.
            """
        class write_circumferential_averaged_profile(TUIMethod):
            """
            Write surface data as a boundary profile file. To use \\*.csv format specify filename with .csv suffix.
            """
        class write_cleanup_script(TUIMethod):
            """
            Write the cleanup-script-file for Fluent.
            """
        class write_currently_defined_profiles(TUIMethod):
            """
            Write currently defined profiles. To use \\*.csv format specify filename with .csv suffix.
            """
        class write_data(TUIMethod):
            """
            Write a data file.
            """
        class write_fan_profile(TUIMethod):
            """
            Compute radial profiles for a fan zone and write them to a profile file.
            """
        class write_field_functions(TUIMethod):
            """
            Write the currently defined custom field functions to a file.
            """
        class write_flamelet(TUIMethod):
            """
            Write a flamelet file.
            """
        class write_injections(TUIMethod):
            """
            Write out selected DPM injections to a file.
            """
        class write_isat_table(TUIMethod):
            """
            Write an ISAT table.
            """
        class write_macros(TUIMethod):
            """
            Write the currently defined macros to a file.
            """
        class write_merge_profiles(TUIMethod):
            """
            Write multiple zones surface data as a single boundary profile file. To use \\*.csv format specify filename with .csv suffix.
            """
        class write_pdat(TUIMethod):
            """
            .
            """
        class write_pdf(TUIMethod):
            """
            Write a pdf file.
            """
        class write_profile(TUIMethod):
            """
            Write surface data as a boundary profile file. To use \\*.csv format specify filename with .csv suffix.
            """
        class write_selected_defined_profiles(TUIMethod):
            """
            Set profile names, only these profile names which will be used during writing of \\*.csv profiles.
            """
        class write_settings(TUIMethod):
            """
            Write out current boundary conditions in use.
            """

        class auto_save(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.append_file_name_with = self.__class__.append_file_name_with(service, version, mode, path + ["append_file_name_with"])
                self.case_frequency = self.__class__.case_frequency(service, version, mode, path + ["case_frequency"])
                self.data_frequency = self.__class__.data_frequency(service, version, mode, path + ["data_frequency"])
                self.max_files = self.__class__.max_files(service, version, mode, path + ["max_files"])
                self.retain_most_recent_files = self.__class__.retain_most_recent_files(service, version, mode, path + ["retain_most_recent_files"])
                self.root_name = self.__class__.root_name(service, version, mode, path + ["root_name"])
                self.save_data_file_every = self.__class__.save_data_file_every(service, version, mode, path + ["save_data_file_every"])
                super().__init__(service, version, mode, path)
            class append_file_name_with(TUIMethod):
                """
                .
                """
            class case_frequency(TUIMethod):
                """
                .
                """
            class data_frequency(TUIMethod):
                """
                .
                """
            class max_files(TUIMethod):
                """
                .
                """
            class retain_most_recent_files(TUIMethod):
                """
                .
                """
            class root_name(TUIMethod):
                """
                .
                """
            class save_data_file_every(TUIMethod):
                """
                .
                """

        class cffio_options(TUIMenu):
            """
            CFF I/O options.
            """
            def __init__(self, service, version, mode, path):
                self.compression_level = self.__class__.compression_level(service, version, mode, path + ["compression_level"])
                self.io_mode = self.__class__.io_mode(service, version, mode, path + ["io_mode"])
                self.single_precision_data = self.__class__.single_precision_data(service, version, mode, path + ["single_precision_data"])
                super().__init__(service, version, mode, path)
            class compression_level(TUIMethod):
                """
                .
                """
            class io_mode(TUIMethod):
                """
                Set CFF I/O mode.
                """
            class single_precision_data(TUIMethod):
                """
                .
                """

        class em_mapping(TUIMenu):
            """
            Assign electro-magnetic losses provided by specified product.
            """
            def __init__(self, service, version, mode, path):
                self.maintain_loss_on_initialization = self.__class__.maintain_loss_on_initialization(service, version, mode, path + ["maintain_loss_on_initialization"])
                self.remove_loss_only = self.__class__.remove_loss_only(service, version, mode, path + ["remove_loss_only"])
                self.surface_energy_source = self.__class__.surface_energy_source(service, version, mode, path + ["surface_energy_source"])
                self.volumetric_energy_source = self.__class__.volumetric_energy_source(service, version, mode, path + ["volumetric_energy_source"])
                super().__init__(service, version, mode, path)
            class maintain_loss_on_initialization(TUIMethod):
                """
                Maintain the loss data provided by Ansoft even if solution is initialized.
                """
            class remove_loss_only(TUIMethod):
                """
                Remove the loss data provided by Ansoft and keep all other solution data.
                """
            class surface_energy_source(TUIMethod):
                """
                Loss data provided by Ansoft will be assigned to Fluent for selected wall zones.
                """
            class volumetric_energy_source(TUIMethod):
                """
                Loss data provided by Ansoft will be assigned to Fluent for selected cell zones.
                """

        class export(TUIMenu):
            """
            Enter the export menu.
            """
            def __init__(self, service, version, mode, path):
                self.settings = self.__class__.settings(service, version, mode, path + ["settings"])
                self.system_coupling_definition_file_settings = self.__class__.system_coupling_definition_file_settings(service, version, mode, path + ["system_coupling_definition_file_settings"])
                self.abaqus = self.__class__.abaqus(service, version, mode, path + ["abaqus"])
                self.ascii = self.__class__.ascii(service, version, mode, path + ["ascii"])
                self.avs = self.__class__.avs(service, version, mode, path + ["avs"])
                self.cdat_for_cfd_post__and__ensight = self.__class__.cdat_for_cfd_post__and__ensight(service, version, mode, path + ["cdat_for_cfd_post__and__ensight"])
                self.cgns = self.__class__.cgns(service, version, mode, path + ["cgns"])
                self.common_fluids_format_post = self.__class__.common_fluids_format_post(service, version, mode, path + ["common_fluids_format_post"])
                self.custom_heat_flux = self.__class__.custom_heat_flux(service, version, mode, path + ["custom_heat_flux"])
                self.dx = self.__class__.dx(service, version, mode, path + ["dx"])
                self.ensight = self.__class__.ensight(service, version, mode, path + ["ensight"])
                self.ensight_dvs = self.__class__.ensight_dvs(service, version, mode, path + ["ensight_dvs"])
                self.ensight_dvs_surfaces = self.__class__.ensight_dvs_surfaces(service, version, mode, path + ["ensight_dvs_surfaces"])
                self.ensight_dvs_volume = self.__class__.ensight_dvs_volume(service, version, mode, path + ["ensight_dvs_volume"])
                self.ensight_gold = self.__class__.ensight_gold(service, version, mode, path + ["ensight_gold"])
                self.ensight_gold_parallel_surfaces = self.__class__.ensight_gold_parallel_surfaces(service, version, mode, path + ["ensight_gold_parallel_surfaces"])
                self.ensight_gold_parallel_volume = self.__class__.ensight_gold_parallel_volume(service, version, mode, path + ["ensight_gold_parallel_volume"])
                self.fast_mesh = self.__class__.fast_mesh(service, version, mode, path + ["fast_mesh"])
                self.fast_scalar = self.__class__.fast_scalar(service, version, mode, path + ["fast_scalar"])
                self.fast_solution = self.__class__.fast_solution(service, version, mode, path + ["fast_solution"])
                self.fast_velocity = self.__class__.fast_velocity(service, version, mode, path + ["fast_velocity"])
                self.fieldview = self.__class__.fieldview(service, version, mode, path + ["fieldview"])
                self.fieldview_data = self.__class__.fieldview_data(service, version, mode, path + ["fieldview_data"])
                self.fieldview_unstruct = self.__class__.fieldview_unstruct(service, version, mode, path + ["fieldview_unstruct"])
                self.fieldview_unstruct_data = self.__class__.fieldview_unstruct_data(service, version, mode, path + ["fieldview_unstruct_data"])
                self.fieldview_unstruct_mesh = self.__class__.fieldview_unstruct_mesh(service, version, mode, path + ["fieldview_unstruct_mesh"])
                self.fieldview_unstruct_surfaces = self.__class__.fieldview_unstruct_surfaces(service, version, mode, path + ["fieldview_unstruct_surfaces"])
                self.gambit = self.__class__.gambit(service, version, mode, path + ["gambit"])
                self.icemcfd_for_icepak = self.__class__.icemcfd_for_icepak(service, version, mode, path + ["icemcfd_for_icepak"])
                self.ideas = self.__class__.ideas(service, version, mode, path + ["ideas"])
                self.mechanical_apdl = self.__class__.mechanical_apdl(service, version, mode, path + ["mechanical_apdl"])
                self.mechanical_apdl_input = self.__class__.mechanical_apdl_input(service, version, mode, path + ["mechanical_apdl_input"])
                self.nastran = self.__class__.nastran(service, version, mode, path + ["nastran"])
                self.outline_view_settings = self.__class__.outline_view_settings(service, version, mode, path + ["outline_view_settings"])
                self.particle_history_data = self.__class__.particle_history_data(service, version, mode, path + ["particle_history_data"])
                self.patran_neutral = self.__class__.patran_neutral(service, version, mode, path + ["patran_neutral"])
                self.patran_nodal = self.__class__.patran_nodal(service, version, mode, path + ["patran_nodal"])
                self.taitherm = self.__class__.taitherm(service, version, mode, path + ["taitherm"])
                self.tecplot = self.__class__.tecplot(service, version, mode, path + ["tecplot"])
                super().__init__(service, version, mode, path)
            class abaqus(TUIMethod):
                """
                .
                """
            class ascii(TUIMethod):
                """
                Write an ASCII file.
                """
            class avs(TUIMethod):
                """
                Write an AVS UCD file.
                """
            class cdat_for_cfd_post__and__ensight(TUIMethod):
                """
                Write a CDAT for CFD-Post & EnSight file.
                """
            class cgns(TUIMethod):
                """
                Write a CGNS file.
                """
            class common_fluids_format_post(TUIMethod):
                """
                Write an CFF Post-Only file.
                """
            class custom_heat_flux(TUIMethod):
                """
                .
                """
            class dx(TUIMethod):
                """
                Write an IBM Data Explorer format file.
                """
            class ensight(TUIMethod):
                """
                Write EnSight 6 geometry, velocity, and scalar files.
                """
            class ensight_dvs(TUIMethod):
                """
                Write post-processing data (geometry, velocity and scalars) for cell and face zones using EnSight Dynamic Visualization Store Interface.
                """
            class ensight_dvs_surfaces(TUIMethod):
                """
                Write post-processing data (geometry, velocity and scalars) for surfaces using EnSight Dynamic Visualization Store Interface.
                """
            class ensight_dvs_volume(TUIMethod):
                """
                Write post-processing data (geometry, velocity and scalars) for cell zones and boundaries attached to them using EnSight Dynamic Visualization Store Interface.
                """
            class ensight_gold(TUIMethod):
                """
                Write EnSight Gold geometry, velocity, and scalar files.
                """
            class ensight_gold_parallel_surfaces(TUIMethod):
                """
                Write EnSight Gold geometry, velocity and scalar files for surfaces. Fluent will write files suitable for EnSight Parallel.
                """
            class ensight_gold_parallel_volume(TUIMethod):
                """
                Write EnSight Gold geometry, velocity and scalar files for cell zones and boundaries attached to them. Fluent will write files suitable for EnSight Parallel.
                """
            class fast_mesh(TUIMethod):
                """
                .
                """
            class fast_scalar(TUIMethod):
                """
                Write a FAST/Plot3D unstructured scalar function file.
                """
            class fast_solution(TUIMethod):
                """
                .
                """
            class fast_velocity(TUIMethod):
                """
                .
                """
            class fieldview(TUIMethod):
                """
                Write Fieldview case and data files.
                """
            class fieldview_data(TUIMethod):
                """
                Write Fieldview case and data files.
                """
            class fieldview_unstruct(TUIMethod):
                """
                Write a Fieldview unstructured combined file.
                """
            class fieldview_unstruct_data(TUIMethod):
                """
                Write a Fieldview unstructured results only file.
                """
            class fieldview_unstruct_mesh(TUIMethod):
                """
                Write a Fieldview unstructured mesh only file.
                """
            class fieldview_unstruct_surfaces(TUIMethod):
                """
                Write a Fieldview unstructured surface mesh, data.
                """
            class gambit(TUIMethod):
                """
                Write a Gambit neutral file.
                """
            class icemcfd_for_icepak(TUIMethod):
                """
                .
                """
            class ideas(TUIMethod):
                """
                Write an IDEAS universal file.
                """
            class mechanical_apdl(TUIMethod):
                """
                .
                """
            class mechanical_apdl_input(TUIMethod):
                """
                .
                """
            class nastran(TUIMethod):
                """
                Write a NASTRAN file.
                """
            class outline_view_settings(TUIMethod):
                """
                .
                """
            class particle_history_data(TUIMethod):
                """
                Export particle-history data.
                """
            class patran_neutral(TUIMethod):
                """
                Write a PATRAN neutral file.
                """
            class patran_nodal(TUIMethod):
                """
                Write a PATRAN nodal results file.
                """
            class taitherm(TUIMethod):
                """
                .
                """
            class tecplot(TUIMethod):
                """
                Write a Tecplot+3DV format file.
                """

            class settings(TUIMenu):
                """
                Enter the export settings menu.
                """
                def __init__(self, service, version, mode, path):
                    self.cgns_default_cellsize_changes = self.__class__.cgns_default_cellsize_changes(service, version, mode, path + ["cgns_default_cellsize_changes"])
                    self.cgns_enhance_poly_export_performance = self.__class__.cgns_enhance_poly_export_performance(service, version, mode, path + ["cgns_enhance_poly_export_performance"])
                    self.cgns_familyname = self.__class__.cgns_familyname(service, version, mode, path + ["cgns_familyname"])
                    self.cgns_merge_ngons_to_single_ngon = self.__class__.cgns_merge_ngons_to_single_ngon(service, version, mode, path + ["cgns_merge_ngons_to_single_ngon"])
                    self.cgns_mesh_type = self.__class__.cgns_mesh_type(service, version, mode, path + ["cgns_mesh_type"])
                    self.cgns_polyhedral_cpu_threads = self.__class__.cgns_polyhedral_cpu_threads(service, version, mode, path + ["cgns_polyhedral_cpu_threads"])
                    self.cgns_separate_cellzones = self.__class__.cgns_separate_cellzones(service, version, mode, path + ["cgns_separate_cellzones"])
                    self.set_cgns_export_filetype = self.__class__.set_cgns_export_filetype(service, version, mode, path + ["set_cgns_export_filetype"])
                    super().__init__(service, version, mode, path)
                class cgns_default_cellsize_changes(TUIMethod):
                    """
                    .
                    """
                class cgns_enhance_poly_export_performance(TUIMethod):
                    """
                    .
                    """
                class cgns_familyname(TUIMethod):
                    """
                    .
                    """
                class cgns_merge_ngons_to_single_ngon(TUIMethod):
                    """
                    .
                    """
                class cgns_mesh_type(TUIMethod):
                    """
                    Set CGNS NGON mode.
                    """
                class cgns_polyhedral_cpu_threads(TUIMethod):
                    """
                    .
                    """
                class cgns_separate_cellzones(TUIMethod):
                    """
                    .
                    """
                class set_cgns_export_filetype(TUIMethod):
                    """
                    .
                    """

            class system_coupling_definition_file_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.enable_auto_creation_of_scp_file = self.__class__.enable_auto_creation_of_scp_file(service, version, mode, path + ["enable_auto_creation_of_scp_file"])
                    self.write_sc_file = self.__class__.write_sc_file(service, version, mode, path + ["write_sc_file"])
                    super().__init__(service, version, mode, path)
                class enable_auto_creation_of_scp_file(TUIMethod):
                    """
                    .
                    """
                class write_sc_file(TUIMethod):
                    """
                    .
                    """

        class fsi(TUIMenu):
            """
            Enter the fsi menu.
            """
            def __init__(self, service, version, mode, path):
                self.conserve_force = self.__class__.conserve_force(service, version, mode, path + ["conserve_force"])
                self.display_fsi_mesh = self.__class__.display_fsi_mesh(service, version, mode, path + ["display_fsi_mesh"])
                self.read_fsi_mesh = self.__class__.read_fsi_mesh(service, version, mode, path + ["read_fsi_mesh"])
                self.write_fsi_mesh = self.__class__.write_fsi_mesh(service, version, mode, path + ["write_fsi_mesh"])
                super().__init__(service, version, mode, path)
            class conserve_force(TUIMethod):
                """
                Conserve the forces for linear line, tri and tet elements.
                """
            class display_fsi_mesh(TUIMethod):
                """
                Display the FEA mesh that has been read.
                """
            class read_fsi_mesh(TUIMethod):
                """
                Read an FEA mesh for one-way FSI.
                """
            class write_fsi_mesh(TUIMethod):
                """
                Write an FEA mesh file with Fluent data.
                """

        class import_(TUIMenu):
            """
            Enter the import menu.
            """
            def __init__(self, service, version, mode, path):
                self.abaqus = self.__class__.abaqus(service, version, mode, path + ["abaqus"])
                self.cfx = self.__class__.cfx(service, version, mode, path + ["cfx"])
                self.cgns = self.__class__.cgns(service, version, mode, path + ["cgns"])
                self.fmu_file = self.__class__.fmu_file(service, version, mode, path + ["fmu_file"])
                self.lstc = self.__class__.lstc(service, version, mode, path + ["lstc"])
                self.mechanical_apdl = self.__class__.mechanical_apdl(service, version, mode, path + ["mechanical_apdl"])
                self.nastran = self.__class__.nastran(service, version, mode, path + ["nastran"])
                self.partition = self.__class__.partition(service, version, mode, path + ["partition"])
                self.patran = self.__class__.patran(service, version, mode, path + ["patran"])
                self.plot3d = self.__class__.plot3d(service, version, mode, path + ["plot3d"])
                self.tecplot = self.__class__.tecplot(service, version, mode, path + ["tecplot"])
                self.chemkin_mechanism = self.__class__.chemkin_mechanism(service, version, mode, path + ["chemkin_mechanism"])
                self.chemkin_report_each_line = self.__class__.chemkin_report_each_line(service, version, mode, path + ["chemkin_report_each_line"])
                self.ensight = self.__class__.ensight(service, version, mode, path + ["ensight"])
                self.fidap = self.__class__.fidap(service, version, mode, path + ["fidap"])
                self.flamelet = self.__class__.flamelet(service, version, mode, path + ["flamelet"])
                self.fluent4_case = self.__class__.fluent4_case(service, version, mode, path + ["fluent4_case"])
                self.gambit = self.__class__.gambit(service, version, mode, path + ["gambit"])
                self.hypermesh = self.__class__.hypermesh(service, version, mode, path + ["hypermesh"])
                self.ideas_universal = self.__class__.ideas_universal(service, version, mode, path + ["ideas_universal"])
                self.marc_post = self.__class__.marc_post(service, version, mode, path + ["marc_post"])
                self.prebfc_structured = self.__class__.prebfc_structured(service, version, mode, path + ["prebfc_structured"])
                self.ptc_mechanica = self.__class__.ptc_mechanica(service, version, mode, path + ["ptc_mechanica"])
                super().__init__(service, version, mode, path)
            class chemkin_mechanism(TUIMethod):
                """
                Read a CHEMKIN mechanism file.
                """
            class chemkin_report_each_line(TUIMethod):
                """
                Enable/disable reporting after reading each line.
                """
            class ensight(TUIMethod):
                """
                Read an Ensight file as a case file.
                """
            class fidap(TUIMethod):
                """
                Read a FIDAP neutral file as a case file.
                """
            class flamelet(TUIMethod):
                """
                Import a flamelet file.
                """
            class fluent4_case(TUIMethod):
                """
                Read a formatted Fluent 4 case file.
                """
            class gambit(TUIMethod):
                """
                Read a GAMBIT neutral file as a case file.
                """
            class hypermesh(TUIMethod):
                """
                Read a HYPERMESH file as a case file.
                """
            class ideas_universal(TUIMethod):
                """
                Read an IDEAS Universal file as a case file.
                """
            class marc_post(TUIMethod):
                """
                Read a MARC POST file as a case file.
                """
            class prebfc_structured(TUIMethod):
                """
                Read a formatted preBFC structured mesh (grid) file.
                """
            class ptc_mechanica(TUIMethod):
                """
                Read a PTC Mechanica file as a case file.
                """

            class abaqus(TUIMenu):
                """
                Enter the Abaqus menu.
                """
                def __init__(self, service, version, mode, path):
                    self.fil = self.__class__.fil(service, version, mode, path + ["fil"])
                    self.input = self.__class__.input(service, version, mode, path + ["input"])
                    self.odb = self.__class__.odb(service, version, mode, path + ["odb"])
                    super().__init__(service, version, mode, path)
                class fil(TUIMethod):
                    """
                    Read an Abaqus .fil result file as a case file.
                    """
                class input(TUIMethod):
                    """
                    Read an Abaqus Input file as a case file.
                    """
                class odb(TUIMethod):
                    """
                    Read an Abaqus odb file as a case file.
                    """

            class cfx(TUIMenu):
                """
                Enter the CFX menu.
                """
                def __init__(self, service, version, mode, path):
                    self.definition = self.__class__.definition(service, version, mode, path + ["definition"])
                    self.result = self.__class__.result(service, version, mode, path + ["result"])
                    super().__init__(service, version, mode, path)
                class definition(TUIMethod):
                    """
                    Read a CFX definition file as a case file.
                    """
                class result(TUIMethod):
                    """
                    Read a CFX result file as a case file.
                    """

            class cgns(TUIMenu):
                """
                Enter the CGNS menu.
                """
                def __init__(self, service, version, mode, path):
                    self.data = self.__class__.data(service, version, mode, path + ["data"])
                    self.mesh = self.__class__.mesh(service, version, mode, path + ["mesh"])
                    self.mesh_data = self.__class__.mesh_data(service, version, mode, path + ["mesh_data"])
                    super().__init__(service, version, mode, path)
                class data(TUIMethod):
                    """
                    Read data from CGNS file.
                    """
                class mesh(TUIMethod):
                    """
                    Read a CGNS file as a case file.
                    """
                class mesh_data(TUIMethod):
                    """
                    Read a CGNS file as a case file.
                    """

            class fmu_file(TUIMenu):
                """
                Read a FMU file.
                """
                def __init__(self, service, version, mode, path):
                    self.define_fmu = self.__class__.define_fmu(service, version, mode, path + ["define_fmu"])
                    self.import_fmu = self.__class__.import_fmu(service, version, mode, path + ["import_fmu"])
                    self.select_fmu_local = self.__class__.select_fmu_local(service, version, mode, path + ["select_fmu_local"])
                    self.set_fmu_parameter = self.__class__.set_fmu_parameter(service, version, mode, path + ["set_fmu_parameter"])
                    super().__init__(service, version, mode, path)
                class define_fmu(TUIMethod):
                    """
                    Link the FMU variables with Fluent parameters.
                    """
                class import_fmu(TUIMethod):
                    """
                    .
                    """
                class select_fmu_local(TUIMethod):
                    """
                    Select the FMU local variables to monitor.
                    """
                class set_fmu_parameter(TUIMethod):
                    """
                    Change the values of FMU parameter variables.
                    """

            class lstc(TUIMenu):
                """
                Enter the LSTC menu.
                """
                def __init__(self, service, version, mode, path):
                    self.input = self.__class__.input(service, version, mode, path + ["input"])
                    self.state = self.__class__.state(service, version, mode, path + ["state"])
                    super().__init__(service, version, mode, path)
                class input(TUIMethod):
                    """
                    Read an LSTC input file as a case file.
                    """
                class state(TUIMethod):
                    """
                    Read an LSTC result file as a case file.
                    """

            class mechanical_apdl(TUIMenu):
                """
                Enter the Mechanical APDL menu.
                """
                def __init__(self, service, version, mode, path):
                    self.input = self.__class__.input(service, version, mode, path + ["input"])
                    self.result = self.__class__.result(service, version, mode, path + ["result"])
                    super().__init__(service, version, mode, path)
                class input(TUIMethod):
                    """
                    Read an Mechanical APDL file as a case file.
                    """
                class result(TUIMethod):
                    """
                    Read an Mechanical APDL result file as a case file.
                    """

            class nastran(TUIMenu):
                """
                Enter the NASTRAN menu.
                """
                def __init__(self, service, version, mode, path):
                    self.bulkdata = self.__class__.bulkdata(service, version, mode, path + ["bulkdata"])
                    self.output2 = self.__class__.output2(service, version, mode, path + ["output2"])
                    super().__init__(service, version, mode, path)
                class bulkdata(TUIMethod):
                    """
                    Read a NASTRAN file as a case file.
                    """
                class output2(TUIMethod):
                    """
                    Read a NASTRAN op2 file as a case file.
                    """

            class partition(TUIMenu):
                """
                Enter the partition menu.
                """
                def __init__(self, service, version, mode, path):
                    self.metis = self.__class__.metis(service, version, mode, path + ["metis"])
                    self.metis_zone = self.__class__.metis_zone(service, version, mode, path + ["metis_zone"])
                    super().__init__(service, version, mode, path)
                class metis(TUIMethod):
                    """
                    Read and partition a Fluent 5 case file.
                    """
                class metis_zone(TUIMethod):
                    """
                    Read and partition a Fluent 5 case file.
                    """

            class patran(TUIMenu):
                """
                Enter the PATRAN menu.
                """
                def __init__(self, service, version, mode, path):
                    self.neutral = self.__class__.neutral(service, version, mode, path + ["neutral"])
                    super().__init__(service, version, mode, path)
                class neutral(TUIMethod):
                    """
                    Read a PATRAN Neutral file (zones defined by named components) as a case file.
                    """

            class plot3d(TUIMenu):
                """
                Enter the PLOT3D menu.
                """
                def __init__(self, service, version, mode, path):
                    self.mesh = self.__class__.mesh(service, version, mode, path + ["mesh"])
                    super().__init__(service, version, mode, path)
                class mesh(TUIMethod):
                    """
                    Read a PLOT3D file as a case file.
                    """

            class tecplot(TUIMenu):
                """
                Enter the Tecplot menu.
                """
                def __init__(self, service, version, mode, path):
                    self.mesh = self.__class__.mesh(service, version, mode, path + ["mesh"])
                    super().__init__(service, version, mode, path)
                class mesh(TUIMethod):
                    """
                    Read a Tecplot binary file as a case file.
                    """

        class interpolate(TUIMenu):
            """
            Enter the interpolate menu.
            """
            def __init__(self, service, version, mode, path):
                self.read_data = self.__class__.read_data(service, version, mode, path + ["read_data"])
                self.write_data = self.__class__.write_data(service, version, mode, path + ["write_data"])
                self.zone_selection = self.__class__.zone_selection(service, version, mode, path + ["zone_selection"])
                super().__init__(service, version, mode, path)
            class read_data(TUIMethod):
                """
                Read and interpolate data.
                """
            class write_data(TUIMethod):
                """
                Write data for interpolation.
                """
            class zone_selection(TUIMethod):
                """
                Define a list of cell zone IDs. If specified, interpolation data will be
                read/written for these cell zones only.
                """

        class parametric_project(TUIMenu):
            """
            Enter to open, save, archive parametric project.
            """
            def __init__(self, service, version, mode, path):
                self.archive = self.__class__.archive(service, version, mode, path + ["archive"])
                self.open = self.__class__.open(service, version, mode, path + ["open"])
                self.save = self.__class__.save(service, version, mode, path + ["save"])
                self.save_a_copy = self.__class__.save_a_copy(service, version, mode, path + ["save_a_copy"])
                self.save_as = self.__class__.save_as(service, version, mode, path + ["save_as"])
                super().__init__(service, version, mode, path)
            class archive(TUIMethod):
                """
                Archive Project.
                """
            class open(TUIMethod):
                """
                Open project.
                """
            class save(TUIMethod):
                """
                Save Project.
                """
            class save_a_copy(TUIMethod):
                """
                Save a Copy.
                """
            class save_as(TUIMethod):
                """
                Save As Project.
                """

        class project_beta(TUIMenu):
            """
            Enter to create new project, open project, save and archive project.
            """
            def __init__(self, service, version, mode, path):
                self.archive = self.__class__.archive(service, version, mode, path + ["archive"])
                self.new = self.__class__.new(service, version, mode, path + ["new"])
                self.open = self.__class__.open(service, version, mode, path + ["open"])
                self.save = self.__class__.save(service, version, mode, path + ["save"])
                self.save_as = self.__class__.save_as(service, version, mode, path + ["save_as"])
                self.save_as_copy = self.__class__.save_as_copy(service, version, mode, path + ["save_as_copy"])
                super().__init__(service, version, mode, path)
            class archive(TUIMethod):
                """
                Archive Project.
                """
            class new(TUIMethod):
                """
                Create New Project.
                """
            class open(TUIMethod):
                """
                Open project.
                """
            class save(TUIMethod):
                """
                Save Project.
                """
            class save_as(TUIMethod):
                """
                Save As Project.
                """
            class save_as_copy(TUIMethod):
                """
                Save As Copy.
                """

        class solution_files(TUIMenu):
            """
            Enter the solution files menu.
            """
            def __init__(self, service, version, mode, path):
                self.delete_solution = self.__class__.delete_solution(service, version, mode, path + ["delete_solution"])
                self.load_solution = self.__class__.load_solution(service, version, mode, path + ["load_solution"])
                self.print_solution_files = self.__class__.print_solution_files(service, version, mode, path + ["print_solution_files"])
                super().__init__(service, version, mode, path)
            class delete_solution(TUIMethod):
                """
                Delete solution files.
                """
            class load_solution(TUIMethod):
                """
                Load a solution file.
                """
            class print_solution_files(TUIMethod):
                """
                Print list of available solution files.
                """

        class table_manager(TUIMenu):
            """
            Enter the table manager menu.
            """
            def __init__(self, service, version, mode, path):
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.list_matrix_data = self.__class__.list_matrix_data(service, version, mode, path + ["list_matrix_data"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.list_tables = self.__class__.list_tables(service, version, mode, path + ["list_tables"])
                self.read_matrix_data_file = self.__class__.read_matrix_data_file(service, version, mode, path + ["read_matrix_data_file"])
                self.read_rgp_file = self.__class__.read_rgp_file(service, version, mode, path + ["read_rgp_file"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                self.store_in_case_file = self.__class__.store_in_case_file(service, version, mode, path + ["store_in_case_file"])
                super().__init__(service, version, mode, path)
            class delete(TUIMethod):
                """
                Delete a table.
                """
            class list_matrix_data(TUIMethod):
                """
                List matrix table data.
                """
            class list_properties(TUIMethod):
                """
                List the properties for a table.
                """
            class list_tables(TUIMethod):
                """
                List the available tables.
                """
            class read_matrix_data_file(TUIMethod):
                """
                Read matrix data file.
                """
            class read_rgp_file(TUIMethod):
                """
                Read material from real gas property (RGP) file.
                """
            class rename(TUIMethod):
                """
                Rename a table.
                """
            class store_in_case_file(TUIMethod):
                """
                Set persistence mode for tables (in case or separate file).
                """

        class transient_export(TUIMenu):
            """
            Enter the export menu.
            """
            def __init__(self, service, version, mode, path):
                self.settings = self.__class__.settings(service, version, mode, path + ["settings"])
                self.abaqus = self.__class__.abaqus(service, version, mode, path + ["abaqus"])
                self.ascii = self.__class__.ascii(service, version, mode, path + ["ascii"])
                self.avs = self.__class__.avs(service, version, mode, path + ["avs"])
                self.cdat_for_cfd_post__and__ensight = self.__class__.cdat_for_cfd_post__and__ensight(service, version, mode, path + ["cdat_for_cfd_post__and__ensight"])
                self.cgns = self.__class__.cgns(service, version, mode, path + ["cgns"])
                self.common_fluids_format_post = self.__class__.common_fluids_format_post(service, version, mode, path + ["common_fluids_format_post"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.dx = self.__class__.dx(service, version, mode, path + ["dx"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.ensight_dvs = self.__class__.ensight_dvs(service, version, mode, path + ["ensight_dvs"])
                self.ensight_dvs_surfaces = self.__class__.ensight_dvs_surfaces(service, version, mode, path + ["ensight_dvs_surfaces"])
                self.ensight_dvs_volume = self.__class__.ensight_dvs_volume(service, version, mode, path + ["ensight_dvs_volume"])
                self.ensight_gold_from_existing_files = self.__class__.ensight_gold_from_existing_files(service, version, mode, path + ["ensight_gold_from_existing_files"])
                self.ensight_gold_parallel_surfaces = self.__class__.ensight_gold_parallel_surfaces(service, version, mode, path + ["ensight_gold_parallel_surfaces"])
                self.ensight_gold_parallel_volume = self.__class__.ensight_gold_parallel_volume(service, version, mode, path + ["ensight_gold_parallel_volume"])
                self.ensight_gold_transient = self.__class__.ensight_gold_transient(service, version, mode, path + ["ensight_gold_transient"])
                self.fast = self.__class__.fast(service, version, mode, path + ["fast"])
                self.fast_solution = self.__class__.fast_solution(service, version, mode, path + ["fast_solution"])
                self.fieldview_unstruct = self.__class__.fieldview_unstruct(service, version, mode, path + ["fieldview_unstruct"])
                self.fieldview_unstruct_data = self.__class__.fieldview_unstruct_data(service, version, mode, path + ["fieldview_unstruct_data"])
                self.fieldview_unstruct_mesh = self.__class__.fieldview_unstruct_mesh(service, version, mode, path + ["fieldview_unstruct_mesh"])
                self.fieldview_unstruct_surfaces = self.__class__.fieldview_unstruct_surfaces(service, version, mode, path + ["fieldview_unstruct_surfaces"])
                self.ideas = self.__class__.ideas(service, version, mode, path + ["ideas"])
                self.mechanical_apdl_input = self.__class__.mechanical_apdl_input(service, version, mode, path + ["mechanical_apdl_input"])
                self.nastran = self.__class__.nastran(service, version, mode, path + ["nastran"])
                self.particle_history_data = self.__class__.particle_history_data(service, version, mode, path + ["particle_history_data"])
                self.patran_neutral = self.__class__.patran_neutral(service, version, mode, path + ["patran_neutral"])
                self.taitherm = self.__class__.taitherm(service, version, mode, path + ["taitherm"])
                self.tecplot = self.__class__.tecplot(service, version, mode, path + ["tecplot"])
                super().__init__(service, version, mode, path)
            class abaqus(TUIMethod):
                """
                Write an ABAQUS file.
                """
            class ascii(TUIMethod):
                """
                Write an ASCII file.
                """
            class avs(TUIMethod):
                """
                Write an AVS UCD file.
                """
            class cdat_for_cfd_post__and__ensight(TUIMethod):
                """
                Write a CDAT for CFD-Post & EnSight file.
                """
            class cgns(TUIMethod):
                """
                Write a CGNS file.
                """
            class common_fluids_format_post(TUIMethod):
                """
                Write an CFF Post-Only file.
                """
            class delete(TUIMethod):
                """
                Delete transient exports.
                """
            class dx(TUIMethod):
                """
                Write an IBM Data Explorer format file.
                """
            class edit(TUIMethod):
                """
                Edit transient exports.
                """
            class ensight_dvs(TUIMethod):
                """
                Write post-processing data (geometry, velocity and scalars) for cell and face zones using EnSight Dynamic Visualization Store Interface.
                """
            class ensight_dvs_surfaces(TUIMethod):
                """
                Write post-processing data (geometry, velocity and scalars) for surfaces using EnSight Dynamic Visualization Store Interface.
                """
            class ensight_dvs_volume(TUIMethod):
                """
                Write post-processing data (geometry, velocity and scalars) for cell zones and boundaries attached to them using EnSight Dynamic Visualization Store Interface.
                """
            class ensight_gold_from_existing_files(TUIMethod):
                """
                Write EnSight Gold files using Fluent case files.
                """
            class ensight_gold_parallel_surfaces(TUIMethod):
                """
                Write EnSight Gold geometry, velocity and scalar files for surfaces. Fluent will write files suitable for EnSight Parallel.
                """
            class ensight_gold_parallel_volume(TUIMethod):
                """
                Write EnSight Gold geometry, velocity and scalar files for cell zones and boundaries attached to them. Fluent will write files suitable for EnSight Parallel.
                """
            class ensight_gold_transient(TUIMethod):
                """
                Write EnSight Gold geometry, velocity, and scalar files.
                """
            class fast(TUIMethod):
                """
                Write a FAST/Plot3D unstructured mesh velocity scalar file.
                """
            class fast_solution(TUIMethod):
                """
                Write a FAST/Plot3D unstructured solution file.
                """
            class fieldview_unstruct(TUIMethod):
                """
                Write a Fieldview unstructured combined file.
                """
            class fieldview_unstruct_data(TUIMethod):
                """
                Write a Fieldview unstructured results only file.
                """
            class fieldview_unstruct_mesh(TUIMethod):
                """
                Write a Fieldview unstructured mesh only file.
                """
            class fieldview_unstruct_surfaces(TUIMethod):
                """
                Write a Fieldview unstructured combined file for surfaces.
                """
            class ideas(TUIMethod):
                """
                Write an IDEAS universal file.
                """
            class mechanical_apdl_input(TUIMethod):
                """
                Write an Mechanical APDL Input file.
                """
            class nastran(TUIMethod):
                """
                Write a NASTRAN file.
                """
            class particle_history_data(TUIMethod):
                """
                Setup an automatic particle-history data export.
                """
            class patran_neutral(TUIMethod):
                """
                Write a PATRAN neutral file.
                """
            class taitherm(TUIMethod):
                """
                Write a TAITherm file.
                """
            class tecplot(TUIMethod):
                """
                Write a Tecplot+3DV format file.
                """

            class settings(TUIMenu):
                """
                Enter the automatic export settings menu.
                """
                def __init__(self, service, version, mode, path):
                    self.cfd_post_compatible = self.__class__.cfd_post_compatible(service, version, mode, path + ["cfd_post_compatible"])
                    super().__init__(service, version, mode, path)
                class cfd_post_compatible(TUIMethod):
                    """
                    Set settings for CFD-Post compatible file export.
                    """

    class icing(TUIMenu):
        """
        FENSAP-ICE options.
        """
        def __init__(self, service, version, mode, path):
            self.drop = self.__class__.drop(service, version, mode, path + ["drop"])
            self.file = self.__class__.file(service, version, mode, path + ["file"])
            self.flow = self.__class__.flow(service, version, mode, path + ["flow"])
            self.ice = self.__class__.ice(service, version, mode, path + ["ice"])
            self.multishot = self.__class__.multishot(service, version, mode, path + ["multishot"])
            self.settings = self.__class__.settings(service, version, mode, path + ["settings"])
            super().__init__(service, version, mode, path)
        class drop(TUIMethod):
            """
            Droplet impingement menu.
            """
        class file(TUIMethod):
            """
            File menu.
            """
        class flow(TUIMethod):
            """
            Flow solver menu.
            """
        class ice(TUIMethod):
            """
            Ice accretion menu.
            """
        class multishot(TUIMethod):
            """
            Multi-shot accretion menu.
            """
        class settings(TUIMethod):
            """
            Global settings menu.
            """

    class mesh(TUIMenu):
        """
        Enter the mesh menu.
        """
        def __init__(self, service, version, mode, path):
            self.adapt = self.__class__.adapt(service, version, mode, path + ["adapt"])
            self.anisotropic_adaption = self.__class__.anisotropic_adaption(service, version, mode, path + ["anisotropic_adaption"])
            self.geometry = self.__class__.geometry(service, version, mode, path + ["geometry"])
            self.modify_zones = self.__class__.modify_zones(service, version, mode, path + ["modify_zones"])
            self.polyhedra = self.__class__.polyhedra(service, version, mode, path + ["polyhedra"])
            self.reorder = self.__class__.reorder(service, version, mode, path + ["reorder"])
            self.repair_improve = self.__class__.repair_improve(service, version, mode, path + ["repair_improve"])
            self.surface_mesh = self.__class__.surface_mesh(service, version, mode, path + ["surface_mesh"])
            self.adjacency = self.__class__.adjacency(service, version, mode, path + ["adjacency"])
            self.check = self.__class__.check(service, version, mode, path + ["check"])
            self.check_before_solve = self.__class__.check_before_solve(service, version, mode, path + ["check_before_solve"])
            self.check_verbosity = self.__class__.check_verbosity(service, version, mode, path + ["check_verbosity"])
            self.enhanced_orthogonal_quality = self.__class__.enhanced_orthogonal_quality(service, version, mode, path + ["enhanced_orthogonal_quality"])
            self.memory_usage = self.__class__.memory_usage(service, version, mode, path + ["memory_usage"])
            self.mesh_info = self.__class__.mesh_info(service, version, mode, path + ["mesh_info"])
            self.quality = self.__class__.quality(service, version, mode, path + ["quality"])
            self.redistribute_boundary_layer = self.__class__.redistribute_boundary_layer(service, version, mode, path + ["redistribute_boundary_layer"])
            self.replace = self.__class__.replace(service, version, mode, path + ["replace"])
            self.rotate = self.__class__.rotate(service, version, mode, path + ["rotate"])
            self.scale = self.__class__.scale(service, version, mode, path + ["scale"])
            self.show_periodic_shadow_zones = self.__class__.show_periodic_shadow_zones(service, version, mode, path + ["show_periodic_shadow_zones"])
            self.size_info = self.__class__.size_info(service, version, mode, path + ["size_info"])
            self.smooth_mesh = self.__class__.smooth_mesh(service, version, mode, path + ["smooth_mesh"])
            self.swap_mesh_faces = self.__class__.swap_mesh_faces(service, version, mode, path + ["swap_mesh_faces"])
            self.translate = self.__class__.translate(service, version, mode, path + ["translate"])
            self.wall_distance_method = self.__class__.wall_distance_method(service, version, mode, path + ["wall_distance_method"])
            super().__init__(service, version, mode, path)
        class adjacency(TUIMethod):
            """
            .
            """
        class check(TUIMethod):
            """
            .
            """
        class check_before_solve(TUIMethod):
            """
            .
            """
        class check_verbosity(TUIMethod):
            """
            .
            """
        class enhanced_orthogonal_quality(TUIMethod):
            """
            .
            """
        class memory_usage(TUIMethod):
            """
            .
            """
        class mesh_info(TUIMethod):
            """
            .
            """
        class quality(TUIMethod):
            """
            .
            """
        class redistribute_boundary_layer(TUIMethod):
            """
            .
            """
        class replace(TUIMethod):
            """
            .
            """
        class rotate(TUIMethod):
            """
            Rotate the mesh.
            """
        class scale(TUIMethod):
            """
            Scale the mesh.
            """
        class show_periodic_shadow_zones(TUIMethod):
            """
            .
            """
        class size_info(TUIMethod):
            """
            .
            """
        class smooth_mesh(TUIMethod):
            """
            Smooth the mesh using quality-based, Laplace or skewness methods.
            """
        class swap_mesh_faces(TUIMethod):
            """
            Swap mesh faces.
            """
        class translate(TUIMethod):
            """
            .
            """
        class wall_distance_method(TUIMethod):
            """
            .
            """

        class adapt(TUIMenu):
            """
            Enter the adaption menu.
            """
            def __init__(self, service, version, mode, path):
                self.cell_registers = self.__class__.cell_registers(service, version, mode, path + ["cell_registers"])
                self.geometry = self.__class__.geometry(service, version, mode, path + ["geometry"])
                self.manage_criteria = self.__class__.manage_criteria(service, version, mode, path + ["manage_criteria"])
                self.multi_layer_refinement = self.__class__.multi_layer_refinement(service, version, mode, path + ["multi_layer_refinement"])
                self.profile = self.__class__.profile(service, version, mode, path + ["profile"])
                self.set = self.__class__.set(service, version, mode, path + ["set"])
                self.adapt_mesh = self.__class__.adapt_mesh(service, version, mode, path + ["adapt_mesh"])
                self.anisotropic_adaption = self.__class__.anisotropic_adaption(service, version, mode, path + ["anisotropic_adaption"])
                self.coarsening_criteria = self.__class__.coarsening_criteria(service, version, mode, path + ["coarsening_criteria"])
                self.display_adaption_cells = self.__class__.display_adaption_cells(service, version, mode, path + ["display_adaption_cells"])
                self.free_hierarchy = self.__class__.free_hierarchy(service, version, mode, path + ["free_hierarchy"])
                self.list_adaption_cells = self.__class__.list_adaption_cells(service, version, mode, path + ["list_adaption_cells"])
                self.manual_coarsening_criteria = self.__class__.manual_coarsening_criteria(service, version, mode, path + ["manual_coarsening_criteria"])
                self.manual_refinement_criteria = self.__class__.manual_refinement_criteria(service, version, mode, path + ["manual_refinement_criteria"])
                self.refinement_criteria = self.__class__.refinement_criteria(service, version, mode, path + ["refinement_criteria"])
                super().__init__(service, version, mode, path)
            class adapt_mesh(TUIMethod):
                """
                .
                """
            class anisotropic_adaption(TUIMethod):
                """
                Anisotropically refine boundary layers.
                """
            class coarsening_criteria(TUIMethod):
                """
                .
                """
            class display_adaption_cells(TUIMethod):
                """
                .
                """
            class free_hierarchy(TUIMethod):
                """
                .
                """
            class list_adaption_cells(TUIMethod):
                """
                .
                """
            class manual_coarsening_criteria(TUIMethod):
                """
                .
                """
            class manual_refinement_criteria(TUIMethod):
                """
                .
                """
            class refinement_criteria(TUIMethod):
                """
                .
                """

            class cell_registers(TUIMenu):
                """
                Manage Cell Registers.
                """
                def __init__(self, service, version, mode, path):
                    self.adapt = self.__class__.adapt(service, version, mode, path + ["adapt"])
                    self.add = self.__class__.add(service, version, mode, path + ["add"])
                    self.apply_poor_mesh_numerics = self.__class__.apply_poor_mesh_numerics(service, version, mode, path + ["apply_poor_mesh_numerics"])
                    self.coarsen = self.__class__.coarsen(service, version, mode, path + ["coarsen"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.refine = self.__class__.refine(service, version, mode, path + ["refine"])
                    super().__init__(service, version, mode, path)
                class adapt(TUIMethod):
                    """
                    Adapt cell register objects.
                    """
                class add(TUIMethod):
                    """
                    Add a new object.
                    """
                class apply_poor_mesh_numerics(TUIMethod):
                    """
                    Apply poor mesh numerics to cell register objects.
                    """
                class coarsen(TUIMethod):
                    """
                    Coarsen cell register objects.
                    """
                class delete(TUIMethod):
                    """
                    Delete an object.
                    """
                class display(TUIMethod):
                    """
                    Display cell register objects.
                    """
                class edit(TUIMethod):
                    """
                    Edit an object.
                    """
                class list(TUIMethod):
                    """
                    List objects.
                    """
                class list_properties(TUIMethod):
                    """
                    List properties of an object.
                    """
                class refine(TUIMethod):
                    """
                    Refine cell register objects.
                    """

            class geometry(TUIMenu):
                """
                Enter the adaption geometry menu.
                """
                def __init__(self, service, version, mode, path):
                    self.manage = self.__class__.manage(service, version, mode, path + ["manage"])
                    self.reconstruct_geometry = self.__class__.reconstruct_geometry(service, version, mode, path + ["reconstruct_geometry"])
                    self.set_geometry_controls = self.__class__.set_geometry_controls(service, version, mode, path + ["set_geometry_controls"])
                    super().__init__(service, version, mode, path)
                class reconstruct_geometry(TUIMethod):
                    """
                    .
                    """
                class set_geometry_controls(TUIMethod):
                    """
                    Set geometry controls for wall zones.
                    """

                class manage(TUIMenu):
                    """
                    Manage geometry-based adaption.
                    """
                    def __init__(self, service, version, mode, path):
                        self.add = self.__class__.add(service, version, mode, path + ["add"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        super().__init__(service, version, mode, path)
                    class add(TUIMethod):
                        """
                        Add a new object.
                        """
                    class delete(TUIMethod):
                        """
                        Delete an object.
                        """
                    class edit(TUIMethod):
                        """
                        Edit an object.
                        """
                    class list(TUIMethod):
                        """
                        List objects.
                        """
                    class list_properties(TUIMethod):
                        """
                        List properties of an object.
                        """

            class manage_criteria(TUIMenu):
                """
                Manage Adaption Criteria.
                """
                def __init__(self, service, version, mode, path):
                    self.add = self.__class__.add(service, version, mode, path + ["add"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    super().__init__(service, version, mode, path)
                class add(TUIMethod):
                    """
                    Add a new object.
                    """
                class delete(TUIMethod):
                    """
                    Delete an object.
                    """
                class edit(TUIMethod):
                    """
                    Edit an object.
                    """
                class list(TUIMethod):
                    """
                    List objects.
                    """
                class list_properties(TUIMethod):
                    """
                    List properties of an object.
                    """

            class multi_layer_refinement(TUIMenu):
                """
                Enter the multiple boundary layer refinement menu.
                """
                def __init__(self, service, version, mode, path):
                    self.boundary_zones = self.__class__.boundary_zones(service, version, mode, path + ["boundary_zones"])
                    self.layer_count = self.__class__.layer_count(service, version, mode, path + ["layer_count"])
                    self.parameters = self.__class__.parameters(service, version, mode, path + ["parameters"])
                    self.refine_mesh = self.__class__.refine_mesh(service, version, mode, path + ["refine_mesh"])
                    super().__init__(service, version, mode, path)
                class boundary_zones(TUIMethod):
                    """
                    Specify boundary zones for refinement.
                    """
                class layer_count(TUIMethod):
                    """
                    Specify the layer count for refinement.
                    """
                class parameters(TUIMethod):
                    """
                    Specify parameters for multiple boundary layer refinement.
                    """
                class refine_mesh(TUIMethod):
                    """
                    Refine the mesh for multiple boundary layers.
                    """

            class profile(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.clear = self.__class__.clear(service, version, mode, path + ["clear"])
                    self.disable = self.__class__.disable(service, version, mode, path + ["disable"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.print = self.__class__.print(service, version, mode, path + ["print"])
                    super().__init__(service, version, mode, path)
                class clear(TUIMethod):
                    """
                    .
                    """
                class disable(TUIMethod):
                    """
                    .
                    """
                class enable(TUIMethod):
                    """
                    .
                    """
                class print(TUIMethod):
                    """
                    .
                    """

            class set(TUIMenu):
                """
                Enter the adaption set menu.
                """
                def __init__(self, service, version, mode, path):
                    self.additional_refinement_layers = self.__class__.additional_refinement_layers(service, version, mode, path + ["additional_refinement_layers"])
                    self.cell_zones = self.__class__.cell_zones(service, version, mode, path + ["cell_zones"])
                    self.display_settings = self.__class__.display_settings(service, version, mode, path + ["display_settings"])
                    self.dynamic_adaption = self.__class__.dynamic_adaption(service, version, mode, path + ["dynamic_adaption"])
                    self.dynamic_adaption_frequency = self.__class__.dynamic_adaption_frequency(service, version, mode, path + ["dynamic_adaption_frequency"])
                    self.encapsulate_children = self.__class__.encapsulate_children(service, version, mode, path + ["encapsulate_children"])
                    self.maximum_cell_count = self.__class__.maximum_cell_count(service, version, mode, path + ["maximum_cell_count"])
                    self.maximum_refinement_level = self.__class__.maximum_refinement_level(service, version, mode, path + ["maximum_refinement_level"])
                    self.method = self.__class__.method(service, version, mode, path + ["method"])
                    self.minimum_cell_quality = self.__class__.minimum_cell_quality(service, version, mode, path + ["minimum_cell_quality"])
                    self.minimum_cell_volume = self.__class__.minimum_cell_volume(service, version, mode, path + ["minimum_cell_volume"])
                    self.minimum_edge_length = self.__class__.minimum_edge_length(service, version, mode, path + ["minimum_edge_length"])
                    self.overset_adapt_dead_cells = self.__class__.overset_adapt_dead_cells(service, version, mode, path + ["overset_adapt_dead_cells"])
                    self.prismatic_adaption = self.__class__.prismatic_adaption(service, version, mode, path + ["prismatic_adaption"])
                    self.prismatic_boundary_zones = self.__class__.prismatic_boundary_zones(service, version, mode, path + ["prismatic_boundary_zones"])
                    self.prismatic_split_ratio = self.__class__.prismatic_split_ratio(service, version, mode, path + ["prismatic_split_ratio"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class additional_refinement_layers(TUIMethod):
                    """
                    .
                    """
                class cell_zones(TUIMethod):
                    """
                    .
                    """
                class display_settings(TUIMethod):
                    """
                    Set the graphics display options for cells marked for adaption.
                    """
                class dynamic_adaption(TUIMethod):
                    """
                    .
                    """
                class dynamic_adaption_frequency(TUIMethod):
                    """
                    .
                    """
                class encapsulate_children(TUIMethod):
                    """
                    .
                    """
                class maximum_cell_count(TUIMethod):
                    """
                    .
                    """
                class maximum_refinement_level(TUIMethod):
                    """
                    .
                    """
                class method(TUIMethod):
                    """
                    Set the adaption method.
                    """
                class minimum_cell_quality(TUIMethod):
                    """
                    .
                    """
                class minimum_cell_volume(TUIMethod):
                    """
                    Set limit on the minimum volume of cells in the mesh.
                    """
                class minimum_edge_length(TUIMethod):
                    """
                    .
                    """
                class overset_adapt_dead_cells(TUIMethod):
                    """
                    .
                    """
                class prismatic_adaption(TUIMethod):
                    """
                    .
                    """
                class prismatic_boundary_zones(TUIMethod):
                    """
                    .
                    """
                class prismatic_split_ratio(TUIMethod):
                    """
                    .
                    """
                class verbosity(TUIMethod):
                    """
                    .
                    """

        class anisotropic_adaption(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.indicator = self.__class__.indicator(service, version, mode, path + ["indicator"])
                self.operations = self.__class__.operations(service, version, mode, path + ["operations"])
                self.target = self.__class__.target(service, version, mode, path + ["target"])
                self.adapt_mesh = self.__class__.adapt_mesh(service, version, mode, path + ["adapt_mesh"])
                self.fixed_zones = self.__class__.fixed_zones(service, version, mode, path + ["fixed_zones"])
                self.iterations = self.__class__.iterations(service, version, mode, path + ["iterations"])
                self.maximum_anisotropic_ratio = self.__class__.maximum_anisotropic_ratio(service, version, mode, path + ["maximum_anisotropic_ratio"])
                self.minimum_cell_quality = self.__class__.minimum_cell_quality(service, version, mode, path + ["minimum_cell_quality"])
                self.minimum_edge_length = self.__class__.minimum_edge_length(service, version, mode, path + ["minimum_edge_length"])
                super().__init__(service, version, mode, path)
            class adapt_mesh(TUIMethod):
                """
                .
                """
            class fixed_zones(TUIMethod):
                """
                .
                """
            class iterations(TUIMethod):
                """
                .
                """
            class maximum_anisotropic_ratio(TUIMethod):
                """
                .
                """
            class minimum_cell_quality(TUIMethod):
                """
                .
                """
            class minimum_edge_length(TUIMethod):
                """
                .
                """

            class indicator(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.indicator_type = self.__class__.indicator_type(service, version, mode, path + ["indicator_type"])
                    self.multi_scalar_fn = self.__class__.multi_scalar_fn(service, version, mode, path + ["multi_scalar_fn"])
                    self.single_scalar_fn = self.__class__.single_scalar_fn(service, version, mode, path + ["single_scalar_fn"])
                    super().__init__(service, version, mode, path)
                class indicator_type(TUIMethod):
                    """
                    .
                    """
                class multi_scalar_fn(TUIMethod):
                    """
                    .
                    """
                class single_scalar_fn(TUIMethod):
                    """
                    .
                    """

            class operations(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.coarsen = self.__class__.coarsen(service, version, mode, path + ["coarsen"])
                    self.move = self.__class__.move(service, version, mode, path + ["move"])
                    self.refine = self.__class__.refine(service, version, mode, path + ["refine"])
                    self.swap = self.__class__.swap(service, version, mode, path + ["swap"])
                    super().__init__(service, version, mode, path)
                class coarsen(TUIMethod):
                    """
                    .
                    """
                class move(TUIMethod):
                    """
                    .
                    """
                class refine(TUIMethod):
                    """
                    .
                    """
                class swap(TUIMethod):
                    """
                    .
                    """

            class target(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.factor_of_cells = self.__class__.factor_of_cells(service, version, mode, path + ["factor_of_cells"])
                    self.number_of_cells = self.__class__.number_of_cells(service, version, mode, path + ["number_of_cells"])
                    self.target_type = self.__class__.target_type(service, version, mode, path + ["target_type"])
                    super().__init__(service, version, mode, path)
                class factor_of_cells(TUIMethod):
                    """
                    .
                    """
                class number_of_cells(TUIMethod):
                    """
                    .
                    """
                class target_type(TUIMethod):
                    """
                    .
                    """

        class geometry(TUIMenu):
            """
            Enter the auxiliary geometry menu.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.display_options = self.__class__.display_options(service, version, mode, path + ["display_options"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class display(TUIMethod):
                """
                Display geometry.
                """
            class display_options(TUIMethod):
                """
                Display options.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """

        class modify_zones(TUIMenu):
            """
            Enter the modify zones menu.
            """
            def __init__(self, service, version, mode, path):
                self.activate_cell_zone = self.__class__.activate_cell_zone(service, version, mode, path + ["activate_cell_zone"])
                self.append_mesh = self.__class__.append_mesh(service, version, mode, path + ["append_mesh"])
                self.append_mesh_data = self.__class__.append_mesh_data(service, version, mode, path + ["append_mesh_data"])
                self.change_zone_state = self.__class__.change_zone_state(service, version, mode, path + ["change_zone_state"])
                self.convert_all_solid_mrf_to_solid_motion = self.__class__.convert_all_solid_mrf_to_solid_motion(service, version, mode, path + ["convert_all_solid_mrf_to_solid_motion"])
                self.copy_cell_zones_by_delta = self.__class__.copy_cell_zones_by_delta(service, version, mode, path + ["copy_cell_zones_by_delta"])
                self.copy_cell_zones_by_offsets = self.__class__.copy_cell_zones_by_offsets(service, version, mode, path + ["copy_cell_zones_by_offsets"])
                self.copy_mesh_to_mrf_motion = self.__class__.copy_mesh_to_mrf_motion(service, version, mode, path + ["copy_mesh_to_mrf_motion"])
                self.copy_move_cell_zone = self.__class__.copy_move_cell_zone(service, version, mode, path + ["copy_move_cell_zone"])
                self.copy_mrf_to_mesh_motion = self.__class__.copy_mrf_to_mesh_motion(service, version, mode, path + ["copy_mrf_to_mesh_motion"])
                self.create_all_shell_threads = self.__class__.create_all_shell_threads(service, version, mode, path + ["create_all_shell_threads"])
                self.create_periodic_interface = self.__class__.create_periodic_interface(service, version, mode, path + ["create_periodic_interface"])
                self.deactivate_cell_zone = self.__class__.deactivate_cell_zone(service, version, mode, path + ["deactivate_cell_zone"])
                self.delete_all_shells = self.__class__.delete_all_shells(service, version, mode, path + ["delete_all_shells"])
                self.delete_cell_by_id = self.__class__.delete_cell_by_id(service, version, mode, path + ["delete_cell_by_id"])
                self.delete_cell_by_mark = self.__class__.delete_cell_by_mark(service, version, mode, path + ["delete_cell_by_mark"])
                self.delete_cell_zone = self.__class__.delete_cell_zone(service, version, mode, path + ["delete_cell_zone"])
                self.extrude_face_zone_delta = self.__class__.extrude_face_zone_delta(service, version, mode, path + ["extrude_face_zone_delta"])
                self.extrude_face_zone_para = self.__class__.extrude_face_zone_para(service, version, mode, path + ["extrude_face_zone_para"])
                self.fuse_face_zones = self.__class__.fuse_face_zones(service, version, mode, path + ["fuse_face_zones"])
                self.list_zones = self.__class__.list_zones(service, version, mode, path + ["list_zones"])
                self.make_periodic = self.__class__.make_periodic(service, version, mode, path + ["make_periodic"])
                self.matching_tolerance = self.__class__.matching_tolerance(service, version, mode, path + ["matching_tolerance"])
                self.merge_zones = self.__class__.merge_zones(service, version, mode, path + ["merge_zones"])
                self.mrf_to_sliding_mesh = self.__class__.mrf_to_sliding_mesh(service, version, mode, path + ["mrf_to_sliding_mesh"])
                self.orient_face_zone = self.__class__.orient_face_zone(service, version, mode, path + ["orient_face_zone"])
                self.recreate_all_shells = self.__class__.recreate_all_shells(service, version, mode, path + ["recreate_all_shells"])
                self.replace_zone = self.__class__.replace_zone(service, version, mode, path + ["replace_zone"])
                self.rotate_zone = self.__class__.rotate_zone(service, version, mode, path + ["rotate_zone"])
                self.scale_zone = self.__class__.scale_zone(service, version, mode, path + ["scale_zone"])
                self.sep_cell_zone_mark = self.__class__.sep_cell_zone_mark(service, version, mode, path + ["sep_cell_zone_mark"])
                self.sep_cell_zone_region = self.__class__.sep_cell_zone_region(service, version, mode, path + ["sep_cell_zone_region"])
                self.sep_face_zone_angle = self.__class__.sep_face_zone_angle(service, version, mode, path + ["sep_face_zone_angle"])
                self.sep_face_zone_face = self.__class__.sep_face_zone_face(service, version, mode, path + ["sep_face_zone_face"])
                self.sep_face_zone_mark = self.__class__.sep_face_zone_mark(service, version, mode, path + ["sep_face_zone_mark"])
                self.sep_face_zone_region = self.__class__.sep_face_zone_region(service, version, mode, path + ["sep_face_zone_region"])
                self.slit_face_zone = self.__class__.slit_face_zone(service, version, mode, path + ["slit_face_zone"])
                self.slit_interior_between_diff_solids = self.__class__.slit_interior_between_diff_solids(service, version, mode, path + ["slit_interior_between_diff_solids"])
                self.slit_periodic = self.__class__.slit_periodic(service, version, mode, path + ["slit_periodic"])
                self.translate_zone = self.__class__.translate_zone(service, version, mode, path + ["translate_zone"])
                self.zone_name = self.__class__.zone_name(service, version, mode, path + ["zone_name"])
                self.zone_type = self.__class__.zone_type(service, version, mode, path + ["zone_type"])
                super().__init__(service, version, mode, path)
            class activate_cell_zone(TUIMethod):
                """
                .
                """
            class append_mesh(TUIMethod):
                """
                .
                """
            class append_mesh_data(TUIMethod):
                """
                .
                """
            class change_zone_state(TUIMethod):
                """
                .
                """
            class convert_all_solid_mrf_to_solid_motion(TUIMethod):
                """
                .
                """
            class copy_cell_zones_by_delta(TUIMethod):
                """
                .
                """
            class copy_cell_zones_by_offsets(TUIMethod):
                """
                .
                """
            class copy_mesh_to_mrf_motion(TUIMethod):
                """
                .
                """
            class copy_move_cell_zone(TUIMethod):
                """
                .
                """
            class copy_mrf_to_mesh_motion(TUIMethod):
                """
                .
                """
            class create_all_shell_threads(TUIMethod):
                """
                .
                """
            class create_periodic_interface(TUIMethod):
                """
                .
                """
            class deactivate_cell_zone(TUIMethod):
                """
                .
                """
            class delete_all_shells(TUIMethod):
                """
                .
                """
            class delete_cell_by_id(TUIMethod):
                """
                .
                """
            class delete_cell_by_mark(TUIMethod):
                """
                .
                """
            class delete_cell_zone(TUIMethod):
                """
                .
                """
            class extrude_face_zone_delta(TUIMethod):
                """
                .
                """
            class extrude_face_zone_para(TUIMethod):
                """
                .
                """
            class fuse_face_zones(TUIMethod):
                """
                .
                """
            class list_zones(TUIMethod):
                """
                .
                """
            class make_periodic(TUIMethod):
                """
                Attempt to establish conformal periodic face zone connectivity.
                """
            class matching_tolerance(TUIMethod):
                """
                .
                """
            class merge_zones(TUIMethod):
                """
                .
                """
            class mrf_to_sliding_mesh(TUIMethod):
                """
                .
                """
            class orient_face_zone(TUIMethod):
                """
                .
                """
            class recreate_all_shells(TUIMethod):
                """
                .
                """
            class replace_zone(TUIMethod):
                """
                .
                """
            class rotate_zone(TUIMethod):
                """
                .
                """
            class scale_zone(TUIMethod):
                """
                .
                """
            class sep_cell_zone_mark(TUIMethod):
                """
                .
                """
            class sep_cell_zone_region(TUIMethod):
                """
                .
                """
            class sep_face_zone_angle(TUIMethod):
                """
                .
                """
            class sep_face_zone_face(TUIMethod):
                """
                .
                """
            class sep_face_zone_mark(TUIMethod):
                """
                .
                """
            class sep_face_zone_region(TUIMethod):
                """
                .
                """
            class slit_face_zone(TUIMethod):
                """
                .
                """
            class slit_interior_between_diff_solids(TUIMethod):
                """
                .
                """
            class slit_periodic(TUIMethod):
                """
                .
                """
            class translate_zone(TUIMethod):
                """
                .
                """
            class zone_name(TUIMethod):
                """
                .
                """
            class zone_type(TUIMethod):
                """
                Set a zone's type.
                """

        class polyhedra(TUIMenu):
            """
            Enter the polyhedra menu.
            """
            def __init__(self, service, version, mode, path):
                self.options = self.__class__.options(service, version, mode, path + ["options"])
                self.convert_domain = self.__class__.convert_domain(service, version, mode, path + ["convert_domain"])
                self.convert_hanging_nodes = self.__class__.convert_hanging_nodes(service, version, mode, path + ["convert_hanging_nodes"])
                self.convert_hanging_nodes_zones = self.__class__.convert_hanging_nodes_zones(service, version, mode, path + ["convert_hanging_nodes_zones"])
                self.convert_skewed_cells = self.__class__.convert_skewed_cells(service, version, mode, path + ["convert_skewed_cells"])
                super().__init__(service, version, mode, path)
            class convert_domain(TUIMethod):
                """
                Convert entire domain to polyhedra cells.
                """
            class convert_hanging_nodes(TUIMethod):
                """
                Convert cells with hanging nodes and faces to polyhedra.
                """
            class convert_hanging_nodes_zones(TUIMethod):
                """
                Convert selected cell zones with hanging nodes and faces to polyhedra.
                The selected cell zones cannot be connected to other zones.
                """
            class convert_skewed_cells(TUIMethod):
                """
                Convert skewed cells to polyhedra.
                """

            class options(TUIMenu):
                """
                Enter options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.migrate_and_reorder = self.__class__.migrate_and_reorder(service, version, mode, path + ["migrate_and_reorder"])
                    self.preserve_boundary_layer = self.__class__.preserve_boundary_layer(service, version, mode, path + ["preserve_boundary_layer"])
                    self.preserve_interior_zones = self.__class__.preserve_interior_zones(service, version, mode, path + ["preserve_interior_zones"])
                    super().__init__(service, version, mode, path)
                class migrate_and_reorder(TUIMethod):
                    """
                    .
                    """
                class preserve_boundary_layer(TUIMethod):
                    """
                    .
                    """
                class preserve_interior_zones(TUIMethod):
                    """
                    Interior zones with matching name pattern are preserved during polyhedra conversion.
                    """

        class reorder(TUIMenu):
            """
            Enter the reorder domain menu.
            """
            def __init__(self, service, version, mode, path):
                self.band_width = self.__class__.band_width(service, version, mode, path + ["band_width"])
                self.reorder_domain = self.__class__.reorder_domain(service, version, mode, path + ["reorder_domain"])
                self.reorder_zones = self.__class__.reorder_zones(service, version, mode, path + ["reorder_zones"])
                super().__init__(service, version, mode, path)
            class band_width(TUIMethod):
                """
                .
                """
            class reorder_domain(TUIMethod):
                """
                .
                """
            class reorder_zones(TUIMethod):
                """
                .
                """

        class repair_improve(TUIMenu):
            """
            Enter the repair and improve quality menu.
            """
            def __init__(self, service, version, mode, path):
                self.allow_repair_at_boundaries = self.__class__.allow_repair_at_boundaries(service, version, mode, path + ["allow_repair_at_boundaries"])
                self.improve_quality = self.__class__.improve_quality(service, version, mode, path + ["improve_quality"])
                self.include_local_polyhedra_conversion_in_repair = self.__class__.include_local_polyhedra_conversion_in_repair(service, version, mode, path + ["include_local_polyhedra_conversion_in_repair"])
                self.repair = self.__class__.repair(service, version, mode, path + ["repair"])
                self.repair_face_handedness = self.__class__.repair_face_handedness(service, version, mode, path + ["repair_face_handedness"])
                self.repair_face_node_order = self.__class__.repair_face_node_order(service, version, mode, path + ["repair_face_node_order"])
                self.repair_periodic = self.__class__.repair_periodic(service, version, mode, path + ["repair_periodic"])
                self.repair_wall_distance = self.__class__.repair_wall_distance(service, version, mode, path + ["repair_wall_distance"])
                self.report_poor_elements = self.__class__.report_poor_elements(service, version, mode, path + ["report_poor_elements"])
                super().__init__(service, version, mode, path)
            class allow_repair_at_boundaries(TUIMethod):
                """
                .
                """
            class improve_quality(TUIMethod):
                """
                .
                """
            class include_local_polyhedra_conversion_in_repair(TUIMethod):
                """
                .
                """
            class repair(TUIMethod):
                """
                .
                """
            class repair_face_handedness(TUIMethod):
                """
                .
                """
            class repair_face_node_order(TUIMethod):
                """
                .
                """
            class repair_periodic(TUIMethod):
                """
                Modify mesh to enforce specified periodic rotation angle.
                """
            class repair_wall_distance(TUIMethod):
                """
                .
                """
            class report_poor_elements(TUIMethod):
                """
                .
                """

        class surface_mesh(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.read = self.__class__.read(service, version, mode, path + ["read"])
                super().__init__(service, version, mode, path)
            class delete(TUIMethod):
                """
                .
                """
            class display(TUIMethod):
                """
                .
                """
            class read(TUIMethod):
                """
                .
                """

    class parallel(TUIMenu):
        """
        Enter the parallel processing menu.
        """
        def __init__(self, service, version, mode, path):
            self.gpgpu = self.__class__.gpgpu(service, version, mode, path + ["gpgpu"])
            self.load_balance = self.__class__.load_balance(service, version, mode, path + ["load_balance"])
            self.multidomain = self.__class__.multidomain(service, version, mode, path + ["multidomain"])
            self.network = self.__class__.network(service, version, mode, path + ["network"])
            self.partition = self.__class__.partition(service, version, mode, path + ["partition"])
            self.set = self.__class__.set(service, version, mode, path + ["set"])
            self.timer = self.__class__.timer(service, version, mode, path + ["timer"])
            self.bandwidth = self.__class__.bandwidth(service, version, mode, path + ["bandwidth"])
            self.check = self.__class__.check(service, version, mode, path + ["check"])
            self.check_verbosity = self.__class__.check_verbosity(service, version, mode, path + ["check_verbosity"])
            self.latency = self.__class__.latency(service, version, mode, path + ["latency"])
            self.show_connectivity = self.__class__.show_connectivity(service, version, mode, path + ["show_connectivity"])
            self.thread_number_control = self.__class__.thread_number_control(service, version, mode, path + ["thread_number_control"])
            super().__init__(service, version, mode, path)
        class bandwidth(TUIMethod):
            """
            .
            """
        class check(TUIMethod):
            """
            .
            """
        class check_verbosity(TUIMethod):
            """
            .
            """
        class latency(TUIMethod):
            """
            .
            """
        class show_connectivity(TUIMethod):
            """
            .
            """
        class thread_number_control(TUIMethod):
            """
            .
            """

        class gpgpu(TUIMenu):
            """
            Select and show gpgpu.
            """
            def __init__(self, service, version, mode, path):
                self.select = self.__class__.select(service, version, mode, path + ["select"])
                self.show = self.__class__.show(service, version, mode, path + ["show"])
                super().__init__(service, version, mode, path)
            class select(TUIMethod):
                """
                Select gpgpu.
                """
            class show(TUIMethod):
                """
                Show gpgpu.
                """

        class load_balance(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.dynamic_mesh = self.__class__.dynamic_mesh(service, version, mode, path + ["dynamic_mesh"])
                self.mesh_adaption = self.__class__.mesh_adaption(service, version, mode, path + ["mesh_adaption"])
                self.physical_models = self.__class__.physical_models(service, version, mode, path + ["physical_models"])
                super().__init__(service, version, mode, path)
            class dynamic_mesh(TUIMethod):
                """
                .
                """
            class mesh_adaption(TUIMethod):
                """
                .
                """
            class physical_models(TUIMethod):
                """
                .
                """

        class multidomain(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.conjugate_heat_transfer = self.__class__.conjugate_heat_transfer(service, version, mode, path + ["conjugate_heat_transfer"])
                self.solve = self.__class__.solve(service, version, mode, path + ["solve"])
                super().__init__(service, version, mode, path)

            class conjugate_heat_transfer(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.set = self.__class__.set(service, version, mode, path + ["set"])
                    self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                    super().__init__(service, version, mode, path)
                class enabled(TUIMethod):
                    """
                    .
                    """

                class set(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.helper_session_setup = self.__class__.helper_session_setup(service, version, mode, path + ["helper_session_setup"])
                        self.coupling = self.__class__.coupling(service, version, mode, path + ["coupling"])
                        self.helper_session = self.__class__.helper_session(service, version, mode, path + ["helper_session"])
                        super().__init__(service, version, mode, path)
                    class coupling(TUIMethod):
                        """
                        .
                        """
                    class helper_session(TUIMethod):
                        """
                        .
                        """

                    class helper_session_setup(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.host_name = self.__class__.host_name(service, version, mode, path + ["host_name"])
                            self.process_count = self.__class__.process_count(service, version, mode, path + ["process_count"])
                            super().__init__(service, version, mode, path)
                        class host_name(TUIMethod):
                            """
                            .
                            """
                        class process_count(TUIMethod):
                            """
                            .
                            """

            class solve(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.dual_time_iterate = self.__class__.dual_time_iterate(service, version, mode, path + ["dual_time_iterate"])
                    self.iterate = self.__class__.iterate(service, version, mode, path + ["iterate"])
                    super().__init__(service, version, mode, path)
                class dual_time_iterate(TUIMethod):
                    """
                    .
                    """
                class iterate(TUIMethod):
                    """
                    .
                    """

        class network(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.kill_all_nodes = self.__class__.kill_all_nodes(service, version, mode, path + ["kill_all_nodes"])
                self.kill_node = self.__class__.kill_node(service, version, mode, path + ["kill_node"])
                self.load_hosts = self.__class__.load_hosts(service, version, mode, path + ["load_hosts"])
                self.save_hosts = self.__class__.save_hosts(service, version, mode, path + ["save_hosts"])
                self.shell_script_path = self.__class__.shell_script_path(service, version, mode, path + ["shell_script_path"])
                self.spawn_node = self.__class__.spawn_node(service, version, mode, path + ["spawn_node"])
                super().__init__(service, version, mode, path)
            class kill_all_nodes(TUIMethod):
                """
                .
                """
            class kill_node(TUIMethod):
                """
                .
                """
            class load_hosts(TUIMethod):
                """
                .
                """
            class save_hosts(TUIMethod):
                """
                .
                """
            class shell_script_path(TUIMethod):
                """
                .
                """
            class spawn_node(TUIMethod):
                """
                .
                """

        class partition(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.automatic = self.__class__.automatic(service, version, mode, path + ["automatic"])
                self.set = self.__class__.set(service, version, mode, path + ["set"])
                self.combine_partition = self.__class__.combine_partition(service, version, mode, path + ["combine_partition"])
                self.merge_clusters = self.__class__.merge_clusters(service, version, mode, path + ["merge_clusters"])
                self.method = self.__class__.method(service, version, mode, path + ["method"])
                self.print_active_partitions = self.__class__.print_active_partitions(service, version, mode, path + ["print_active_partitions"])
                self.print_partitions = self.__class__.print_partitions(service, version, mode, path + ["print_partitions"])
                self.print_stored_partitions = self.__class__.print_stored_partitions(service, version, mode, path + ["print_stored_partitions"])
                self.reorder_partitions = self.__class__.reorder_partitions(service, version, mode, path + ["reorder_partitions"])
                self.reorder_partitions_to_architecture = self.__class__.reorder_partitions_to_architecture(service, version, mode, path + ["reorder_partitions_to_architecture"])
                self.smooth_partition = self.__class__.smooth_partition(service, version, mode, path + ["smooth_partition"])
                self.use_stored_partitions = self.__class__.use_stored_partitions(service, version, mode, path + ["use_stored_partitions"])
                super().__init__(service, version, mode, path)
            class combine_partition(TUIMethod):
                """
                .
                """
            class merge_clusters(TUIMethod):
                """
                .
                """
            class method(TUIMethod):
                """
                .
                """
            class print_active_partitions(TUIMethod):
                """
                .
                """
            class print_partitions(TUIMethod):
                """
                .
                """
            class print_stored_partitions(TUIMethod):
                """
                .
                """
            class reorder_partitions(TUIMethod):
                """
                .
                """
            class reorder_partitions_to_architecture(TUIMethod):
                """
                .
                """
            class smooth_partition(TUIMethod):
                """
                .
                """
            class use_stored_partitions(TUIMethod):
                """
                .
                """

            class automatic(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.across_zones = self.__class__.across_zones(service, version, mode, path + ["across_zones"])
                    self.load_vector = self.__class__.load_vector(service, version, mode, path + ["load_vector"])
                    self.method = self.__class__.method(service, version, mode, path + ["method"])
                    self.pre_test = self.__class__.pre_test(service, version, mode, path + ["pre_test"])
                    self.use_case_file_method = self.__class__.use_case_file_method(service, version, mode, path + ["use_case_file_method"])
                    super().__init__(service, version, mode, path)
                class across_zones(TUIMethod):
                    """
                    .
                    """
                class load_vector(TUIMethod):
                    """
                    .
                    """
                class method(TUIMethod):
                    """
                    .
                    """
                class pre_test(TUIMethod):
                    """
                    .
                    """
                class use_case_file_method(TUIMethod):
                    """
                    .
                    """

            class set(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.partition_origin_vector = self.__class__.partition_origin_vector(service, version, mode, path + ["partition_origin_vector"])
                    self.across_zone_boundaries = self.__class__.across_zone_boundaries(service, version, mode, path + ["across_zone_boundaries"])
                    self.across_zones = self.__class__.across_zones(service, version, mode, path + ["across_zones"])
                    self.all_off = self.__class__.all_off(service, version, mode, path + ["all_off"])
                    self.all_on = self.__class__.all_on(service, version, mode, path + ["all_on"])
                    self.cell_function = self.__class__.cell_function(service, version, mode, path + ["cell_function"])
                    self.dpm_load_balancing = self.__class__.dpm_load_balancing(service, version, mode, path + ["dpm_load_balancing"])
                    self.face_area_as_weights = self.__class__.face_area_as_weights(service, version, mode, path + ["face_area_as_weights"])
                    self.fluid_solid_rebalance_after_read_case = self.__class__.fluid_solid_rebalance_after_read_case(service, version, mode, path + ["fluid_solid_rebalance_after_read_case"])
                    self.isat_weight = self.__class__.isat_weight(service, version, mode, path + ["isat_weight"])
                    self.laplace_smoothing = self.__class__.laplace_smoothing(service, version, mode, path + ["laplace_smoothing"])
                    self.layering = self.__class__.layering(service, version, mode, path + ["layering"])
                    self.load_distribution = self.__class__.load_distribution(service, version, mode, path + ["load_distribution"])
                    self.merge = self.__class__.merge(service, version, mode, path + ["merge"])
                    self.model_weighted_partition = self.__class__.model_weighted_partition(service, version, mode, path + ["model_weighted_partition"])
                    self.nfaces_as_weights = self.__class__.nfaces_as_weights(service, version, mode, path + ["nfaces_as_weights"])
                    self.origin = self.__class__.origin(service, version, mode, path + ["origin"])
                    self.particle_weight = self.__class__.particle_weight(service, version, mode, path + ["particle_weight"])
                    self.pre_test = self.__class__.pre_test(service, version, mode, path + ["pre_test"])
                    self.print_verbosity = self.__class__.print_verbosity(service, version, mode, path + ["print_verbosity"])
                    self.smooth = self.__class__.smooth(service, version, mode, path + ["smooth"])
                    self.solid_thread_weight = self.__class__.solid_thread_weight(service, version, mode, path + ["solid_thread_weight"])
                    self.stiff_chemistry_weight = self.__class__.stiff_chemistry_weight(service, version, mode, path + ["stiff_chemistry_weight"])
                    self.stretched_mesh_enhancement = self.__class__.stretched_mesh_enhancement(service, version, mode, path + ["stretched_mesh_enhancement"])
                    self.vof_free_surface_weight = self.__class__.vof_free_surface_weight(service, version, mode, path + ["vof_free_surface_weight"])
                    super().__init__(service, version, mode, path)
                class across_zone_boundaries(TUIMethod):
                    """
                    .
                    """
                class across_zones(TUIMethod):
                    """
                    .
                    """
                class all_off(TUIMethod):
                    """
                    .
                    """
                class all_on(TUIMethod):
                    """
                    .
                    """
                class cell_function(TUIMethod):
                    """
                    .
                    """
                class dpm_load_balancing(TUIMethod):
                    """
                    .
                    """
                class face_area_as_weights(TUIMethod):
                    """
                    .
                    """
                class fluid_solid_rebalance_after_read_case(TUIMethod):
                    """
                    .
                    """
                class isat_weight(TUIMethod):
                    """
                    .
                    """
                class laplace_smoothing(TUIMethod):
                    """
                    .
                    """
                class layering(TUIMethod):
                    """
                    .
                    """
                class load_distribution(TUIMethod):
                    """
                    .
                    """
                class merge(TUIMethod):
                    """
                    .
                    """
                class model_weighted_partition(TUIMethod):
                    """
                    .
                    """
                class nfaces_as_weights(TUIMethod):
                    """
                    .
                    """
                class origin(TUIMethod):
                    """
                    .
                    """
                class particle_weight(TUIMethod):
                    """
                    .
                    """
                class pre_test(TUIMethod):
                    """
                    .
                    """
                class print_verbosity(TUIMethod):
                    """
                    .
                    """
                class smooth(TUIMethod):
                    """
                    .
                    """
                class solid_thread_weight(TUIMethod):
                    """
                    .
                    """
                class stiff_chemistry_weight(TUIMethod):
                    """
                    .
                    """
                class stretched_mesh_enhancement(TUIMethod):
                    """
                    .
                    """
                class vof_free_surface_weight(TUIMethod):
                    """
                    .
                    """

                class partition_origin_vector(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit partition-origin-vector object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

        class set(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.fast_io = self.__class__.fast_io(service, version, mode, path + ["fast_io"])
                self.partition_mask = self.__class__.partition_mask(service, version, mode, path + ["partition_mask"])
                self.time_out = self.__class__.time_out(service, version, mode, path + ["time_out"])
                self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                super().__init__(service, version, mode, path)
            class fast_io(TUIMethod):
                """
                .
                """
            class partition_mask(TUIMethod):
                """
                .
                """
            class time_out(TUIMethod):
                """
                .
                """
            class verbosity(TUIMethod):
                """
                .
                """

        class timer(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.reset = self.__class__.reset(service, version, mode, path + ["reset"])
                self.usage = self.__class__.usage(service, version, mode, path + ["usage"])
                super().__init__(service, version, mode, path)
            class reset(TUIMethod):
                """
                .
                """
            class usage(TUIMethod):
                """
                .
                """

    class parameters(TUIMenu):
        """
        .
        """
        def __init__(self, service, version, mode, path):
            self.input_parameters = self.__class__.input_parameters(service, version, mode, path + ["input_parameters"])
            self.output_parameters = self.__class__.output_parameters(service, version, mode, path + ["output_parameters"])
            self.enable_in_tui = self.__class__.enable_in_tui(service, version, mode, path + ["enable_in_tui"])
            super().__init__(service, version, mode, path)
        class enable_in_tui(TUIMethod):
            """
            .
            """

        class input_parameters(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.expression = self.__class__.expression(service, version, mode, path + ["expression"])
                self.scheme_proc = self.__class__.scheme_proc(service, version, mode, path + ["scheme_proc"])
                self.udf_side = self.__class__.udf_side(service, version, mode, path + ["udf_side"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                super().__init__(service, version, mode, path)
            class list(TUIMethod):
                """
                .
                """

            class expression(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit expression object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class scheme_proc(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit scheme-proc object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class udf_side(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit udf-side object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

        class output_parameters(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.named_expressions = self.__class__.named_expressions(service, version, mode, path + ["named_expressions"])
                self.report_definitions = self.__class__.report_definitions(service, version, mode, path + ["report_definitions"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.print_all_to_console = self.__class__.print_all_to_console(service, version, mode, path + ["print_all_to_console"])
                self.write_all_to_file = self.__class__.write_all_to_file(service, version, mode, path + ["write_all_to_file"])
                super().__init__(service, version, mode, path)
            class list(TUIMethod):
                """
                .
                """
            class print_all_to_console(TUIMethod):
                """
                .
                """
            class write_all_to_file(TUIMethod):
                """
                .
                """

            class named_expressions(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.print_to_console = self.__class__.print_to_console(service, version, mode, path + ["print_to_console"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    self.write_to_file = self.__class__.write_to_file(service, version, mode, path + ["write_to_file"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit named-expressions object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class print_to_console(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """
                class write_to_file(TUIMethod):
                    """
                    .
                    """

            class report_definitions(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.print_to_console = self.__class__.print_to_console(service, version, mode, path + ["print_to_console"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    self.write_to_file = self.__class__.write_to_file(service, version, mode, path + ["write_to_file"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit report-definitions object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class print_to_console(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """
                class write_to_file(TUIMethod):
                    """
                    .
                    """

    class parametric_study(TUIMenu):
        """
        Enter the parametric study menu.
        """
        def __init__(self, service, version, mode, path):
            self.design_points = self.__class__.design_points(service, version, mode, path + ["design_points"])
            self.study = self.__class__.study(service, version, mode, path + ["study"])
            self.update = self.__class__.update(service, version, mode, path + ["update"])
            self.case_settings_changed = self.__class__.case_settings_changed(service, version, mode, path + ["case_settings_changed"])
            self.delete_study = self.__class__.delete_study(service, version, mode, path + ["delete_study"])
            self.duplicate_study = self.__class__.duplicate_study(service, version, mode, path + ["duplicate_study"])
            self.export_design_table = self.__class__.export_design_table(service, version, mode, path + ["export_design_table"])
            self.import_design_table = self.__class__.import_design_table(service, version, mode, path + ["import_design_table"])
            self.initialize = self.__class__.initialize(service, version, mode, path + ["initialize"])
            self.list_studies = self.__class__.list_studies(service, version, mode, path + ["list_studies"])
            self.rename_study = self.__class__.rename_study(service, version, mode, path + ["rename_study"])
            self.set_as_current_study = self.__class__.set_as_current_study(service, version, mode, path + ["set_as_current_study"])
            self.use_base_data = self.__class__.use_base_data(service, version, mode, path + ["use_base_data"])
            super().__init__(service, version, mode, path)
        class case_settings_changed(TUIMethod):
            """
            Check if case settings are changed.
            """
        class delete_study(TUIMethod):
            """
            Delete Study.
            """
        class duplicate_study(TUIMethod):
            """
            Duplicate Parametric Study.
            """
        class export_design_table(TUIMethod):
            """
            Export Design Point Table.
            """
        class import_design_table(TUIMethod):
            """
            Import Design Point Table.
            """
        class initialize(TUIMethod):
            """
            Start Parametric Study.
            """
        class list_studies(TUIMethod):
            """
            List Studies.
            """
        class rename_study(TUIMethod):
            """
            Rename Study.
            """
        class set_as_current_study(TUIMethod):
            """
            Set As Current Study.
            """
        class use_base_data(TUIMethod):
            """
            Use Base Data.
            """

        class design_points(TUIMenu):
            """
            Enter the design points menu.
            """
            def __init__(self, service, version, mode, path):
                self.auto_create = self.__class__.auto_create(service, version, mode, path + ["auto_create"])
                self.concurrent = self.__class__.concurrent(service, version, mode, path + ["concurrent"])
                self.print_to_console = self.__class__.print_to_console(service, version, mode, path + ["print_to_console"])
                self.set = self.__class__.set(service, version, mode, path + ["set"])
                self.table = self.__class__.table(service, version, mode, path + ["table"])
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.clear_data_and_edit_values = self.__class__.clear_data_and_edit_values(service, version, mode, path + ["clear_data_and_edit_values"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.duplicate = self.__class__.duplicate(service, version, mode, path + ["duplicate"])
                self.load_case_data_for_current_dp = self.__class__.load_case_data_for_current_dp(service, version, mode, path + ["load_case_data_for_current_dp"])
                self.save_journals = self.__class__.save_journals(service, version, mode, path + ["save_journals"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add new design point.
                """
            class clear_data_and_edit_values(TUIMethod):
                """
                Clear Generated Data.
                """
            class delete(TUIMethod):
                """
                Delete Design Point.
                """
            class duplicate(TUIMethod):
                """
                Duplicate Design Point.
                """
            class load_case_data_for_current_dp(TUIMethod):
                """
                Loads relevant case/data file for current design point.
                """
            class save_journals(TUIMethod):
                """
                Save Journals.
                """

            class auto_create(TUIMenu):
                """
                Enter the auto-crate design points menu.
                """
                def __init__(self, service, version, mode, path):
                    self.optimize = self.__class__.optimize(service, version, mode, path + ["optimize"])
                    self.create_design_points = self.__class__.create_design_points(service, version, mode, path + ["create_design_points"])
                    self.export_designs = self.__class__.export_designs(service, version, mode, path + ["export_designs"])
                    self.get_number_of_designs = self.__class__.get_number_of_designs(service, version, mode, path + ["get_number_of_designs"])
                    self.go_to_optislang = self.__class__.go_to_optislang(service, version, mode, path + ["go_to_optislang"])
                    self.list_current_settings = self.__class__.list_current_settings(service, version, mode, path + ["list_current_settings"])
                    self.open_designs_in_optislang_postprocessor = self.__class__.open_designs_in_optislang_postprocessor(service, version, mode, path + ["open_designs_in_optislang_postprocessor"])
                    self.set_parameter_as_active_or_inactive = self.__class__.set_parameter_as_active_or_inactive(service, version, mode, path + ["set_parameter_as_active_or_inactive"])
                    super().__init__(service, version, mode, path)
                class create_design_points(TUIMethod):
                    """
                    Create design points automatically.
                    """
                class export_designs(TUIMethod):
                    """
                    Export designs by writing a JSON file.
                    """
                class get_number_of_designs(TUIMethod):
                    """
                    Get number of designs.
                    """
                class go_to_optislang(TUIMethod):
                    """
                    Open the optiSLang project.
                    """
                class list_current_settings(TUIMethod):
                    """
                    List current settings for auto-create design points.
                    """
                class open_designs_in_optislang_postprocessor(TUIMethod):
                    """
                    Export designs into JSON and open this JSON into optiSLang Postprocessor.
                    """
                class set_parameter_as_active_or_inactive(TUIMethod):
                    """
                    Set the parameter as Active or Inactive.
                    """

                class optimize(TUIMenu):
                    """
                    Enter Optimize menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.print_to_console = self.__class__.print_to_console(service, version, mode, path + ["print_to_console"])
                        self.set = self.__class__.set(service, version, mode, path + ["set"])
                        self.export_omdb_in_optislang_postprocessor = self.__class__.export_omdb_in_optislang_postprocessor(service, version, mode, path + ["export_omdb_in_optislang_postprocessor"])
                        self.export_optimization_results_to_csv = self.__class__.export_optimization_results_to_csv(service, version, mode, path + ["export_optimization_results_to_csv"])
                        self.new_optimization = self.__class__.new_optimization(service, version, mode, path + ["new_optimization"])
                        self.run_optimization = self.__class__.run_optimization(service, version, mode, path + ["run_optimization"])
                        super().__init__(service, version, mode, path)
                    class export_omdb_in_optislang_postprocessor(TUIMethod):
                        """
                        Export OMDB in optiSLang Postprocessor.
                        """
                    class export_optimization_results_to_csv(TUIMethod):
                        """
                        Export optimization results to csv.
                        """
                    class new_optimization(TUIMethod):
                        """
                        Start new optimization.
                        """
                    class run_optimization(TUIMethod):
                        """
                        Run optimization.
                        """

                    class print_to_console(TUIMenu):
                        """
                        Enter print-to-console menu for Optimization.
                        """
                        def __init__(self, service, version, mode, path):
                            self.algorithm_settings = self.__class__.algorithm_settings(service, version, mode, path + ["algorithm_settings"])
                            self.active_and_inactive = self.__class__.active_and_inactive(service, version, mode, path + ["active_and_inactive"])
                            self.algorithm = self.__class__.algorithm(service, version, mode, path + ["algorithm"])
                            self.best_design_of_study = self.__class__.best_design_of_study(service, version, mode, path + ["best_design_of_study"])
                            self.criteria = self.__class__.criteria(service, version, mode, path + ["criteria"])
                            self.results_csv_path = self.__class__.results_csv_path(service, version, mode, path + ["results_csv_path"])
                            super().__init__(service, version, mode, path)
                        class active_and_inactive(TUIMethod):
                            """
                            Print whether a parameter is active or inactive.
                            """
                        class algorithm(TUIMethod):
                            """
                            Print current algorithm.
                            """
                        class best_design_of_study(TUIMethod):
                            """
                            Print best design (if any).
                            """
                        class criteria(TUIMethod):
                            """
                            Print criteria.
                            """
                        class results_csv_path(TUIMethod):
                            """
                            Path to write output results.
                            """

                        class algorithm_settings(TUIMenu):
                            """
                            Enter algorithm-properties menu.
                            """
                            def __init__(self, service, version, mode, path):
                                self.consider_failed_designs = self.__class__.consider_failed_designs(service, version, mode, path + ["consider_failed_designs"])
                                self.export_fmu = self.__class__.export_fmu(service, version, mode, path + ["export_fmu"])
                                self.imp_of_criteria = self.__class__.imp_of_criteria(service, version, mode, path + ["imp_of_criteria"])
                                self.imp_of_local_cop = self.__class__.imp_of_local_cop(service, version, mode, path + ["imp_of_local_cop"])
                                self.imp_of_sample_density = self.__class__.imp_of_sample_density(service, version, mode, path + ["imp_of_sample_density"])
                                self.iteration_number_of_samples_or_levels = self.__class__.iteration_number_of_samples_or_levels(service, version, mode, path + ["iteration_number_of_samples_or_levels"])
                                self.iteration_sampling_type = self.__class__.iteration_sampling_type(service, version, mode, path + ["iteration_sampling_type"])
                                self.max_iterations = self.__class__.max_iterations(service, version, mode, path + ["max_iterations"])
                                self.max_number_of_samples = self.__class__.max_number_of_samples(service, version, mode, path + ["max_number_of_samples"])
                                self.number_of_designs_in_parallel = self.__class__.number_of_designs_in_parallel(service, version, mode, path + ["number_of_designs_in_parallel"])
                                self.number_of_stagnation_iterations = self.__class__.number_of_stagnation_iterations(service, version, mode, path + ["number_of_stagnation_iterations"])
                                self.refinement_number_of_samples = self.__class__.refinement_number_of_samples(service, version, mode, path + ["refinement_number_of_samples"])
                                self.refinement_sampling_type = self.__class__.refinement_sampling_type(service, version, mode, path + ["refinement_sampling_type"])
                                self.refinement_type = self.__class__.refinement_type(service, version, mode, path + ["refinement_type"])
                                self.seed_value = self.__class__.seed_value(service, version, mode, path + ["seed_value"])
                                self.stagnation_iterations = self.__class__.stagnation_iterations(service, version, mode, path + ["stagnation_iterations"])
                                self.target_cop = self.__class__.target_cop(service, version, mode, path + ["target_cop"])
                                self.use_mop = self.__class__.use_mop(service, version, mode, path + ["use_mop"])
                                self.use_start_designs_only = self.__class__.use_start_designs_only(service, version, mode, path + ["use_start_designs_only"])
                                super().__init__(service, version, mode, path)
                            class consider_failed_designs(TUIMethod):
                                """
                                Print value for consider failed designs.
                                """
                            class export_fmu(TUIMethod):
                                """
                                Print value for export FMU.
                                """
                            class imp_of_criteria(TUIMethod):
                                """
                                Print value for importance of criteria.
                                """
                            class imp_of_local_cop(TUIMethod):
                                """
                                Print value for importance of local CoP.
                                """
                            class imp_of_sample_density(TUIMethod):
                                """
                                Set value for importance of weight density.
                                """
                            class iteration_number_of_samples_or_levels(TUIMethod):
                                """
                                Print iteration number of samples.
                                """
                            class iteration_sampling_type(TUIMethod):
                                """
                                Print iteration sampling type.
                                """
                            class max_iterations(TUIMethod):
                                """
                                Print value for maximum iterations.
                                """
                            class max_number_of_samples(TUIMethod):
                                """
                                Print maximum number of samples.
                                """
                            class number_of_designs_in_parallel(TUIMethod):
                                """
                                Print value of Number of designs in parallel.
                                """
                            class number_of_stagnation_iterations(TUIMethod):
                                """
                                Print value of Number of stagnation evaluations.
                                """
                            class refinement_number_of_samples(TUIMethod):
                                """
                                Set refinement number of samples.
                                """
                            class refinement_sampling_type(TUIMethod):
                                """
                                Print refinement sampling type.
                                """
                            class refinement_type(TUIMethod):
                                """
                                Print refinement type.
                                """
                            class seed_value(TUIMethod):
                                """
                                Print Seed Value.
                                """
                            class stagnation_iterations(TUIMethod):
                                """
                                Print value for stagnation iterations.
                                """
                            class target_cop(TUIMethod):
                                """
                                Print value for target CoP.
                                """
                            class use_mop(TUIMethod):
                                """
                                Print the value for Use MOP.
                                """
                            class use_start_designs_only(TUIMethod):
                                """
                                Print value for use start designs only.
                                """

                    class set(TUIMenu):
                        """
                        Enter Set menu for Optimization.
                        """
                        def __init__(self, service, version, mode, path):
                            self.algorithm_settings = self.__class__.algorithm_settings(service, version, mode, path + ["algorithm_settings"])
                            self.criteria = self.__class__.criteria(service, version, mode, path + ["criteria"])
                            self.algorithm = self.__class__.algorithm(service, version, mode, path + ["algorithm"])
                            self.configure_algorithm_settings = self.__class__.configure_algorithm_settings(service, version, mode, path + ["configure_algorithm_settings"])
                            self.lower_and_upper_bounds = self.__class__.lower_and_upper_bounds(service, version, mode, path + ["lower_and_upper_bounds"])
                            self.results_csv_path = self.__class__.results_csv_path(service, version, mode, path + ["results_csv_path"])
                            self.set_parameter_as_active_or_inactive = self.__class__.set_parameter_as_active_or_inactive(service, version, mode, path + ["set_parameter_as_active_or_inactive"])
                            super().__init__(service, version, mode, path)
                        class algorithm(TUIMethod):
                            """
                            Select Optimization Algorithm.
                            """
                        class configure_algorithm_settings(TUIMethod):
                            """
                            Configure the algorithm settings.
                            """
                        class lower_and_upper_bounds(TUIMethod):
                            """
                            Enter Lower and Upper bounds for input parameters.
                            """
                        class results_csv_path(TUIMethod):
                            """
                            Path to write output results.
                            """
                        class set_parameter_as_active_or_inactive(TUIMethod):
                            """
                            Set the parameter as Active or Inactive.
                            """

                        class algorithm_settings(TUIMenu):
                            """
                            Set the algorithm settings.
                            """
                            def __init__(self, service, version, mode, path):
                                self.consider_failed_designs = self.__class__.consider_failed_designs(service, version, mode, path + ["consider_failed_designs"])
                                self.export_fmu = self.__class__.export_fmu(service, version, mode, path + ["export_fmu"])
                                self.imp_of_criteria = self.__class__.imp_of_criteria(service, version, mode, path + ["imp_of_criteria"])
                                self.imp_of_local_cop = self.__class__.imp_of_local_cop(service, version, mode, path + ["imp_of_local_cop"])
                                self.imp_of_sample_density = self.__class__.imp_of_sample_density(service, version, mode, path + ["imp_of_sample_density"])
                                self.iteration_number_of_samples_or_levels = self.__class__.iteration_number_of_samples_or_levels(service, version, mode, path + ["iteration_number_of_samples_or_levels"])
                                self.iteration_sampling_type = self.__class__.iteration_sampling_type(service, version, mode, path + ["iteration_sampling_type"])
                                self.max_iterations = self.__class__.max_iterations(service, version, mode, path + ["max_iterations"])
                                self.max_number_of_samples = self.__class__.max_number_of_samples(service, version, mode, path + ["max_number_of_samples"])
                                self.number_of_designs_in_parallel = self.__class__.number_of_designs_in_parallel(service, version, mode, path + ["number_of_designs_in_parallel"])
                                self.number_of_stagnation_iterations = self.__class__.number_of_stagnation_iterations(service, version, mode, path + ["number_of_stagnation_iterations"])
                                self.refinement_number_of_samples = self.__class__.refinement_number_of_samples(service, version, mode, path + ["refinement_number_of_samples"])
                                self.refinement_sampling_type = self.__class__.refinement_sampling_type(service, version, mode, path + ["refinement_sampling_type"])
                                self.refinement_type = self.__class__.refinement_type(service, version, mode, path + ["refinement_type"])
                                self.seed_value = self.__class__.seed_value(service, version, mode, path + ["seed_value"])
                                self.target_cop = self.__class__.target_cop(service, version, mode, path + ["target_cop"])
                                self.use_mop = self.__class__.use_mop(service, version, mode, path + ["use_mop"])
                                self.use_start_designs_only = self.__class__.use_start_designs_only(service, version, mode, path + ["use_start_designs_only"])
                                super().__init__(service, version, mode, path)
                            class consider_failed_designs(TUIMethod):
                                """
                                Set value for consider failed designs.
                                """
                            class export_fmu(TUIMethod):
                                """
                                Set value for export FMU.
                                """
                            class imp_of_criteria(TUIMethod):
                                """
                                Set value for importance of criteria.
                                """
                            class imp_of_local_cop(TUIMethod):
                                """
                                Set value for importance of local CoP.
                                """
                            class imp_of_sample_density(TUIMethod):
                                """
                                Set value for importance of weight density.
                                """
                            class iteration_number_of_samples_or_levels(TUIMethod):
                                """
                                Set iteration number of samples.
                                """
                            class iteration_sampling_type(TUIMethod):
                                """
                                Set iteration sampling type.
                                """
                            class max_iterations(TUIMethod):
                                """
                                Set value for maximum iterations.
                                """
                            class max_number_of_samples(TUIMethod):
                                """
                                Set maximum number of samples.
                                """
                            class number_of_designs_in_parallel(TUIMethod):
                                """
                                Number of designs in parallel.
                                """
                            class number_of_stagnation_iterations(TUIMethod):
                                """
                                Number of stagnation evaluations.
                                """
                            class refinement_number_of_samples(TUIMethod):
                                """
                                Set refinement number of samples.
                                """
                            class refinement_sampling_type(TUIMethod):
                                """
                                Set refinement sampling type.
                                """
                            class refinement_type(TUIMethod):
                                """
                                Set the Refinement Type.
                                """
                            class seed_value(TUIMethod):
                                """
                                Seed Value.
                                """
                            class target_cop(TUIMethod):
                                """
                                Set value for target CoP.
                                """
                            class use_mop(TUIMethod):
                                """
                                Set value fir Use MOP.
                                """
                            class use_start_designs_only(TUIMethod):
                                """
                                Set value for use start designs only.
                                """

                        class criteria(TUIMenu):
                            """
                            Enter Criteria menu.
                            """
                            def __init__(self, service, version, mode, path):
                                self.add = self.__class__.add(service, version, mode, path + ["add"])
                                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                                super().__init__(service, version, mode, path)
                            class add(TUIMethod):
                                """
                                Add Criteria.
                                """
                            class delete(TUIMethod):
                                """
                                Delete Criteria.
                                """
                            class edit(TUIMethod):
                                """
                                Edit Criteria.
                                """

            class concurrent(TUIMenu):
                """
                Enter the concurrent design points menu.
                """
                def __init__(self, service, version, mode, path):
                    self.abort_all_design_points = self.__class__.abort_all_design_points(service, version, mode, path + ["abort_all_design_points"])
                    self.abort_design_point = self.__class__.abort_design_point(service, version, mode, path + ["abort_design_point"])
                    self.connect_to_web_ui = self.__class__.connect_to_web_ui(service, version, mode, path + ["connect_to_web_ui"])
                    self.download_output_files = self.__class__.download_output_files(service, version, mode, path + ["download_output_files"])
                    self.interrupt_all_design_points = self.__class__.interrupt_all_design_points(service, version, mode, path + ["interrupt_all_design_points"])
                    self.interrupt_design_point = self.__class__.interrupt_design_point(service, version, mode, path + ["interrupt_design_point"])
                    self.refresh_status = self.__class__.refresh_status(service, version, mode, path + ["refresh_status"])
                    super().__init__(service, version, mode, path)
                class abort_all_design_points(TUIMethod):
                    """
                    Abort All Design Points.
                    """
                class abort_design_point(TUIMethod):
                    """
                    Abort Design Point.
                    """
                class connect_to_web_ui(TUIMethod):
                    """
                    Print and connect to the Web UI URL.
                    """
                class download_output_files(TUIMethod):
                    """
                    Download Output Files.
                    """
                class interrupt_all_design_points(TUIMethod):
                    """
                    Interrupt All Design Points.
                    """
                class interrupt_design_point(TUIMethod):
                    """
                    Interrupt Design Point.
                    """
                class refresh_status(TUIMethod):
                    """
                    Refresh Status.
                    """

            class print_to_console(TUIMenu):
                """
                Enter the design points print menu.
                """
                def __init__(self, service, version, mode, path):
                    self.capture_simulation_report_data = self.__class__.capture_simulation_report_data(service, version, mode, path + ["capture_simulation_report_data"])
                    self.current_dp = self.__class__.current_dp(service, version, mode, path + ["current_dp"])
                    self.input_parameters_of_dp = self.__class__.input_parameters_of_dp(service, version, mode, path + ["input_parameters_of_dp"])
                    self.output_parameters_of_dp = self.__class__.output_parameters_of_dp(service, version, mode, path + ["output_parameters_of_dp"])
                    self.status_of_all_dps = self.__class__.status_of_all_dps(service, version, mode, path + ["status_of_all_dps"])
                    self.status_of_dp = self.__class__.status_of_dp(service, version, mode, path + ["status_of_dp"])
                    self.write_data = self.__class__.write_data(service, version, mode, path + ["write_data"])
                    super().__init__(service, version, mode, path)
                class capture_simulation_report_data(TUIMethod):
                    """
                    Print Capture Simulation Report Data option for Design Point.
                    """
                class current_dp(TUIMethod):
                    """
                    Print Name of Current Design Point.
                    """
                class input_parameters_of_dp(TUIMethod):
                    """
                    Print Input Parameter Values of Current Design Point.
                    """
                class output_parameters_of_dp(TUIMethod):
                    """
                    Print Output Parameter Values of Design Point.
                    """
                class status_of_all_dps(TUIMethod):
                    """
                    Print Statuses of all Design Points.
                    """
                class status_of_dp(TUIMethod):
                    """
                    Print Status of given DP.
                    """
                class write_data(TUIMethod):
                    """
                    Print WriteData option for Design Point.
                    """

            class set(TUIMenu):
                """
                Enter the design points Set menu.
                """
                def __init__(self, service, version, mode, path):
                    self.capture_simulation_report_data = self.__class__.capture_simulation_report_data(service, version, mode, path + ["capture_simulation_report_data"])
                    self.current_dp = self.__class__.current_dp(service, version, mode, path + ["current_dp"])
                    self.input_parameters_of_dp = self.__class__.input_parameters_of_dp(service, version, mode, path + ["input_parameters_of_dp"])
                    self.write_data = self.__class__.write_data(service, version, mode, path + ["write_data"])
                    super().__init__(service, version, mode, path)
                class capture_simulation_report_data(TUIMethod):
                    """
                    Set Capture Simulation Report Data option for Design Point.
                    """
                class current_dp(TUIMethod):
                    """
                    Set current design point.
                    """
                class input_parameters_of_dp(TUIMethod):
                    """
                    Set Input Parameter Values of Design Point.
                    """
                class write_data(TUIMethod):
                    """
                    Set WriteData option for Design Point.
                    """

            class table(TUIMenu):
                """
                Enter the design point table menu.
                """
                def __init__(self, service, version, mode, path):
                    self.export_design_table = self.__class__.export_design_table(service, version, mode, path + ["export_design_table"])
                    self.import_design_table = self.__class__.import_design_table(service, version, mode, path + ["import_design_table"])
                    super().__init__(service, version, mode, path)
                class export_design_table(TUIMethod):
                    """
                    Export Design Points Table.
                    """
                class import_design_table(TUIMethod):
                    """
                    Import Design Points Table.
                    """

        class study(TUIMenu):
            """
            Enter the study menu.
            """
            def __init__(self, service, version, mode, path):
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.duplicate = self.__class__.duplicate(service, version, mode, path + ["duplicate"])
                self.initialize = self.__class__.initialize(service, version, mode, path + ["initialize"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.read_case_before_each_dp_update = self.__class__.read_case_before_each_dp_update(service, version, mode, path + ["read_case_before_each_dp_update"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                self.set_as_current = self.__class__.set_as_current(service, version, mode, path + ["set_as_current"])
                self.use_base_data = self.__class__.use_base_data(service, version, mode, path + ["use_base_data"])
                self.use_data_of_previous_dp = self.__class__.use_data_of_previous_dp(service, version, mode, path + ["use_data_of_previous_dp"])
                super().__init__(service, version, mode, path)
            class delete(TUIMethod):
                """
                Delete Study.
                """
            class duplicate(TUIMethod):
                """
                Duplicate Parametric Study.
                """
            class initialize(TUIMethod):
                """
                Start Parametric Study.
                """
            class list(TUIMethod):
                """
                List Studies.
                """
            class read_case_before_each_dp_update(TUIMethod):
                """
                Start Design Point Update from Base case.
                """
            class rename(TUIMethod):
                """
                Rename Study.
                """
            class set_as_current(TUIMethod):
                """
                Set As Current Study.
                """
            class use_base_data(TUIMethod):
                """
                Use Base Data to Initialize a Design Point.
                """
            class use_data_of_previous_dp(TUIMethod):
                """
                Use Data of Previous Updated Design Point.
                """

        class update(TUIMenu):
            """
            Enter the update menu.
            """
            def __init__(self, service, version, mode, path):
                self.concurrent = self.__class__.concurrent(service, version, mode, path + ["concurrent"])
                self.auto_update_mesh_morphs = self.__class__.auto_update_mesh_morphs(service, version, mode, path + ["auto_update_mesh_morphs"])
                self.print_update_method = self.__class__.print_update_method(service, version, mode, path + ["print_update_method"])
                self.set_update_method = self.__class__.set_update_method(service, version, mode, path + ["set_update_method"])
                self.update_all = self.__class__.update_all(service, version, mode, path + ["update_all"])
                self.update_current = self.__class__.update_current(service, version, mode, path + ["update_current"])
                self.update_selected_design_points = self.__class__.update_selected_design_points(service, version, mode, path + ["update_selected_design_points"])
                super().__init__(service, version, mode, path)
            class auto_update_mesh_morphs(TUIMethod):
                """
                Enable Auto Mesh Morphing Update.
                """
            class print_update_method(TUIMethod):
                """
                Print update method.
                """
            class set_update_method(TUIMethod):
                """
                Set update method.
                """
            class update_all(TUIMethod):
                """
                Update All Design Points.
                """
            class update_current(TUIMethod):
                """
                Update Current Design Point.
                """
            class update_selected_design_points(TUIMethod):
                """
                Update Selected Design Points.
                """

            class concurrent(TUIMenu):
                """
                Enter Concurrent Update menu.
                """
                def __init__(self, service, version, mode, path):
                    self.licensing = self.__class__.licensing(service, version, mode, path + ["licensing"])
                    self.print_to_console = self.__class__.print_to_console(service, version, mode, path + ["print_to_console"])
                    self.set = self.__class__.set(service, version, mode, path + ["set"])
                    super().__init__(service, version, mode, path)

                class licensing(TUIMenu):
                    """
                    Enter Concurrent Licensing menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.print_to_console = self.__class__.print_to_console(service, version, mode, path + ["print_to_console"])
                        self.set = self.__class__.set(service, version, mode, path + ["set"])
                        super().__init__(service, version, mode, path)

                    class print_to_console(TUIMenu):
                        """
                        Print Concurrent Licensing Settings.
                        """
                        def __init__(self, service, version, mode, path):
                            self.license_type = self.__class__.license_type(service, version, mode, path + ["license_type"])
                            self.optislang_license_count = self.__class__.optislang_license_count(service, version, mode, path + ["optislang_license_count"])
                            self.optislang_license_type = self.__class__.optislang_license_type(service, version, mode, path + ["optislang_license_type"])
                            super().__init__(service, version, mode, path)
                        class license_type(TUIMethod):
                            """
                            License Type.
                            """
                        class optislang_license_count(TUIMethod):
                            """
                            OptiSLang License Count.
                            """
                        class optislang_license_type(TUIMethod):
                            """
                            OptiSLang License Type.
                            """

                    class set(TUIMenu):
                        """
                        Enter Concurrent Licensing Menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.license_type = self.__class__.license_type(service, version, mode, path + ["license_type"])
                            self.optislang_license_count = self.__class__.optislang_license_count(service, version, mode, path + ["optislang_license_count"])
                            self.optislang_license_type = self.__class__.optislang_license_type(service, version, mode, path + ["optislang_license_type"])
                            super().__init__(service, version, mode, path)
                        class license_type(TUIMethod):
                            """
                            License Type.
                            """
                        class optislang_license_count(TUIMethod):
                            """
                            OptiSLang License Count.
                            """
                        class optislang_license_type(TUIMethod):
                            """
                            OptiSLang License Type.
                            """

                class print_to_console(TUIMenu):
                    """
                    Print to console concurrent options.
                    """
                    def __init__(self, service, version, mode, path):
                        self.capability = self.__class__.capability(service, version, mode, path + ["capability"])
                        self.cluster_details = self.__class__.cluster_details(service, version, mode, path + ["cluster_details"])
                        self.current_endpoint = self.__class__.current_endpoint(service, version, mode, path + ["current_endpoint"])
                        self.current_queue = self.__class__.current_queue(service, version, mode, path + ["current_queue"])
                        self.exclusive = self.__class__.exclusive(service, version, mode, path + ["exclusive"])
                        self.launch_web_server = self.__class__.launch_web_server(service, version, mode, path + ["launch_web_server"])
                        self.maximum_execution_time = self.__class__.maximum_execution_time(service, version, mode, path + ["maximum_execution_time"])
                        self.mode = self.__class__.mode(service, version, mode, path + ["mode"])
                        self.mpi_type = self.__class__.mpi_type(service, version, mode, path + ["mpi_type"])
                        self.number_of_concurrent_dps = self.__class__.number_of_concurrent_dps(service, version, mode, path + ["number_of_concurrent_dps"])
                        self.number_of_cores = self.__class__.number_of_cores(service, version, mode, path + ["number_of_cores"])
                        self.number_of_cpus_per_node = self.__class__.number_of_cpus_per_node(service, version, mode, path + ["number_of_cpus_per_node"])
                        self.number_of_gpus_per_node = self.__class__.number_of_gpus_per_node(service, version, mode, path + ["number_of_gpus_per_node"])
                        self.output_files_to_keep = self.__class__.output_files_to_keep(service, version, mode, path + ["output_files_to_keep"])
                        self.use_gpu_solver = self.__class__.use_gpu_solver(service, version, mode, path + ["use_gpu_solver"])
                        self.web_server_token = self.__class__.web_server_token(service, version, mode, path + ["web_server_token"])
                        super().__init__(service, version, mode, path)
                    class capability(TUIMethod):
                        """
                        Print the Capability.
                        """
                    class cluster_details(TUIMethod):
                        """
                        Print the Cluster Details.
                        """
                    class current_endpoint(TUIMethod):
                        """
                        Get the current endpoint.
                        """
                    class current_queue(TUIMethod):
                        """
                        Get the current queue.
                        """
                    class exclusive(TUIMethod):
                        """
                        Print the Exclusive.
                        """
                    class launch_web_server(TUIMethod):
                        """
                        Print the Launch Web Server value.
                        """
                    class maximum_execution_time(TUIMethod):
                        """
                        Print the Maximum Execution Time.
                        """
                    class mode(TUIMethod):
                        """
                        Print Concurrent Mode.
                        """
                    class mpi_type(TUIMethod):
                        """
                        Print the MPI Type.
                        """
                    class number_of_concurrent_dps(TUIMethod):
                        """
                        Print Number of Concurrent Design Points.
                        """
                    class number_of_cores(TUIMethod):
                        """
                        Get Number of Cores per Design Point.
                        """
                    class number_of_cpus_per_node(TUIMethod):
                        """
                        Print Number of CPUs per Node.
                        """
                    class number_of_gpus_per_node(TUIMethod):
                        """
                        Print the Number of GPUs per Node.
                        """
                    class output_files_to_keep(TUIMethod):
                        """
                        Print the Output Files to Keep.
                        """
                    class use_gpu_solver(TUIMethod):
                        """
                        Get state of Use Native GPU Solver option.
                        """
                    class web_server_token(TUIMethod):
                        """
                        Print the Web Server Token.
                        """

                class set(TUIMenu):
                    """
                    Set concurrent update options.
                    """
                    def __init__(self, service, version, mode, path):
                        self.capability = self.__class__.capability(service, version, mode, path + ["capability"])
                        self.cluster_details = self.__class__.cluster_details(service, version, mode, path + ["cluster_details"])
                        self.current_queue = self.__class__.current_queue(service, version, mode, path + ["current_queue"])
                        self.exclusive = self.__class__.exclusive(service, version, mode, path + ["exclusive"])
                        self.launch_web_server = self.__class__.launch_web_server(service, version, mode, path + ["launch_web_server"])
                        self.maximum_execution_time = self.__class__.maximum_execution_time(service, version, mode, path + ["maximum_execution_time"])
                        self.mode = self.__class__.mode(service, version, mode, path + ["mode"])
                        self.mpi_type = self.__class__.mpi_type(service, version, mode, path + ["mpi_type"])
                        self.number_of_concurrent_dps = self.__class__.number_of_concurrent_dps(service, version, mode, path + ["number_of_concurrent_dps"])
                        self.number_of_cores = self.__class__.number_of_cores(service, version, mode, path + ["number_of_cores"])
                        self.number_of_cpus_per_node = self.__class__.number_of_cpus_per_node(service, version, mode, path + ["number_of_cpus_per_node"])
                        self.number_of_gpus_per_node = self.__class__.number_of_gpus_per_node(service, version, mode, path + ["number_of_gpus_per_node"])
                        self.specify_output_files = self.__class__.specify_output_files(service, version, mode, path + ["specify_output_files"])
                        self.use_gpu_solver = self.__class__.use_gpu_solver(service, version, mode, path + ["use_gpu_solver"])
                        self.web_server_token = self.__class__.web_server_token(service, version, mode, path + ["web_server_token"])
                        super().__init__(service, version, mode, path)
                    class capability(TUIMethod):
                        """
                        Set the Capability.
                        """
                    class cluster_details(TUIMethod):
                        """
                        Set the Cluster Details.
                        """
                    class current_queue(TUIMethod):
                        """
                        Set the current queue.
                        """
                    class exclusive(TUIMethod):
                        """
                        Set the Exclusive.
                        """
                    class launch_web_server(TUIMethod):
                        """
                        Launch Web Server.
                        """
                    class maximum_execution_time(TUIMethod):
                        """
                        Set the Maximum Execution Time.
                        """
                    class mode(TUIMethod):
                        """
                        Set the Mode.
                        """
                    class mpi_type(TUIMethod):
                        """
                        Set the MPI Type.
                        """
                    class number_of_concurrent_dps(TUIMethod):
                        """
                        Set Number of Concurrent Design Points.
                        """
                    class number_of_cores(TUIMethod):
                        """
                        Set Number of Cores per Design Point.
                        """
                    class number_of_cpus_per_node(TUIMethod):
                        """
                        Set the Number of CPUs per Node.
                        """
                    class number_of_gpus_per_node(TUIMethod):
                        """
                        Set the Number of GPUs per Node.
                        """
                    class specify_output_files(TUIMethod):
                        """
                        Specify the output files to keep.
                        """
                    class use_gpu_solver(TUIMethod):
                        """
                        Use GPU Solver for Concurrent Runs.
                        """
                    class web_server_token(TUIMethod):
                        """
                        Set the Web Server Token.
                        """

    class plot(TUIMenu):
        """
        Enter the XY plot menu.
        """
        def __init__(self, service, version, mode, path):
            self.ansys_sound_analysis = self.__class__.ansys_sound_analysis(service, version, mode, path + ["ansys_sound_analysis"])
            self.cumulative_plot = self.__class__.cumulative_plot(service, version, mode, path + ["cumulative_plot"])
            self.datasources = self.__class__.datasources(service, version, mode, path + ["datasources"])
            self.fft_set = self.__class__.fft_set(service, version, mode, path + ["fft_set"])
            self.file_set = self.__class__.file_set(service, version, mode, path + ["file_set"])
            self.flamelet_curves = self.__class__.flamelet_curves(service, version, mode, path + ["flamelet_curves"])
            self.histogram_set = self.__class__.histogram_set(service, version, mode, path + ["histogram_set"])
            self.residuals_set = self.__class__.residuals_set(service, version, mode, path + ["residuals_set"])
            self.solution_set = self.__class__.solution_set(service, version, mode, path + ["solution_set"])
            self.vrx_sound_analysis = self.__class__.vrx_sound_analysis(service, version, mode, path + ["vrx_sound_analysis"])
            self.change_fft_ref_pressure = self.__class__.change_fft_ref_pressure(service, version, mode, path + ["change_fft_ref_pressure"])
            self.circum_avg_axial = self.__class__.circum_avg_axial(service, version, mode, path + ["circum_avg_axial"])
            self.circum_avg_radial = self.__class__.circum_avg_radial(service, version, mode, path + ["circum_avg_radial"])
            self.display_profile_data = self.__class__.display_profile_data(service, version, mode, path + ["display_profile_data"])
            self.fft = self.__class__.fft(service, version, mode, path + ["fft"])
            self.file = self.__class__.file(service, version, mode, path + ["file"])
            self.file_list = self.__class__.file_list(service, version, mode, path + ["file_list"])
            self.histogram = self.__class__.histogram(service, version, mode, path + ["histogram"])
            self.label_alignment = self.__class__.label_alignment(service, version, mode, path + ["label_alignment"])
            self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
            self.plot_direction = self.__class__.plot_direction(service, version, mode, path + ["plot_direction"])
            self.residuals = self.__class__.residuals(service, version, mode, path + ["residuals"])
            self.set_boundary_val_off = self.__class__.set_boundary_val_off(service, version, mode, path + ["set_boundary_val_off"])
            self.solution = self.__class__.solution(service, version, mode, path + ["solution"])
            super().__init__(service, version, mode, path)
        class change_fft_ref_pressure(TUIMethod):
            """
            Change acoustic reference pressure.
            """
        class circum_avg_axial(TUIMethod):
            """
            Compute iso-axial band surfaces and plot data vs axial coordinate on them.
            """
        class circum_avg_radial(TUIMethod):
            """
            Compute iso-radial band surfaces and plot data vs radius on them.
            """
        class display_profile_data(TUIMethod):
            """
            Plot Profile Data.
            """
        class fft(TUIMethod):
            """
            Plot FFT of file data.
            """
        class file(TUIMethod):
            """
            .
            """
        class file_list(TUIMethod):
            """
            Plot data from multiple files.
            """
        class histogram(TUIMethod):
            """
            Plot a histogram of a specified scalar quantity.
            """
        class label_alignment(TUIMethod):
            """
            Set the alignment of xy plot label to horizontal or axis aligned.
            """
        class plot(TUIMethod):
            """
            Plot solution on surfaces.
            """
        class plot_direction(TUIMethod):
            """
            Set plot direction for xy plot.
            """
        class residuals(TUIMethod):
            """
            Plot equation residual history.
            """
        class set_boundary_val_off(TUIMethod):
            """
            Set boundary value off when node values off for XY/Solution Plot.
            Note: This setting is valid for current Fluent session only.
            """
        class solution(TUIMethod):
            """
            Plot solution on surfaces and/or zones.
            """

        class ansys_sound_analysis(TUIMenu):
            """
            Ansys Sound analysis and specification.
            """
            def __init__(self, service, version, mode, path):
                self.print_indicators = self.__class__.print_indicators(service, version, mode, path + ["print_indicators"])
                self.write_files = self.__class__.write_files(service, version, mode, path + ["write_files"])
                super().__init__(service, version, mode, path)
            class print_indicators(TUIMethod):
                """
                Print Ansys Sound indicators.
                """
            class write_files(TUIMethod):
                """
                Write Ansys Sound out files.
                """

        class cumulative_plot(TUIMenu):
            """
            Plot Cumulative Force and Moments.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                self.print = self.__class__.print(service, version, mode, path + ["print"])
                self.write = self.__class__.write(service, version, mode, path + ["write"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class axes(TUIMethod):
                """
                Set axes options of an object.
                """
            class curves(TUIMethod):
                """
                Set curves options of an object.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """
            class plot(TUIMethod):
                """
                Plot the Cumulative Forces/Moments.
                """
            class print(TUIMethod):
                """
                Print the Cumulative Forces/Moments.
                """
            class write(TUIMethod):
                """
                Write the Cumulative Forces/Moments.
                """

        class datasources(TUIMenu):
            """
            Enter the menu to set data sources.
            """
            def __init__(self, service, version, mode, path):
                self.add_report_plot = self.__class__.add_report_plot(service, version, mode, path + ["add_report_plot"])
                self.add_xy_plot = self.__class__.add_xy_plot(service, version, mode, path + ["add_xy_plot"])
                self.list_curve_information = self.__class__.list_curve_information(service, version, mode, path + ["list_curve_information"])
                self.list_data_sources = self.__class__.list_data_sources(service, version, mode, path + ["list_data_sources"])
                self.list_legend_names = self.__class__.list_legend_names(service, version, mode, path + ["list_legend_names"])
                self.load_file = self.__class__.load_file(service, version, mode, path + ["load_file"])
                self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                self.properties = self.__class__.properties(service, version, mode, path + ["properties"])
                self.remove_data_source = self.__class__.remove_data_source(service, version, mode, path + ["remove_data_source"])
                self.rename_legend = self.__class__.rename_legend(service, version, mode, path + ["rename_legend"])
                super().__init__(service, version, mode, path)
            class add_report_plot(TUIMethod):
                """
                Add report plot.
                """
            class add_xy_plot(TUIMethod):
                """
                Add xy plot.
                """
            class list_curve_information(TUIMethod):
                """
                List curve information.
                """
            class list_data_sources(TUIMethod):
                """
                List data sources.
                """
            class list_legend_names(TUIMethod):
                """
                List legend names.
                """
            class load_file(TUIMethod):
                """
                Load files.
                """
            class plot(TUIMethod):
                """
                Plot.
                """
            class properties(TUIMethod):
                """
                Properties.
                """
            class remove_data_source(TUIMethod):
                """
                Remove data source.
                """
            class rename_legend(TUIMethod):
                """
                Rename legend.
                """

        class fft_set(TUIMenu):
            """
            Enter the menu to set histogram plot parameters.
            """
            def __init__(self, service, version, mode, path):
                self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                super().__init__(service, version, mode, path)
            class axes(TUIMethod):
                """
                Set axes options of an object.
                """
            class curves(TUIMethod):
                """
                Set curves options of an object.
                """

        class file_set(TUIMenu):
            """
            Enter the menu to set file plot parameters.
            """
            def __init__(self, service, version, mode, path):
                self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
                self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                self.end_plot_to_file = self.__class__.end_plot_to_file(service, version, mode, path + ["end_plot_to_file"])
                self.file_lines = self.__class__.file_lines(service, version, mode, path + ["file_lines"])
                self.file_markers = self.__class__.file_markers(service, version, mode, path + ["file_markers"])
                self.get_residuals_window = self.__class__.get_residuals_window(service, version, mode, path + ["get_residuals_window"])
                self.key = self.__class__.key(service, version, mode, path + ["key"])
                self.labels = self.__class__.labels(service, version, mode, path + ["labels"])
                self.lines = self.__class__.lines(service, version, mode, path + ["lines"])
                self.log = self.__class__.log(service, version, mode, path + ["log"])
                self.markers = self.__class__.markers(service, version, mode, path + ["markers"])
                self.numbers = self.__class__.numbers(service, version, mode, path + ["numbers"])
                self.plot_to_file = self.__class__.plot_to_file(service, version, mode, path + ["plot_to_file"])
                self.rules = self.__class__.rules(service, version, mode, path + ["rules"])
                self.windows = self.__class__.windows(service, version, mode, path + ["windows"])
                self.xy_percent_y = self.__class__.xy_percent_y(service, version, mode, path + ["xy_percent_y"])
                super().__init__(service, version, mode, path)
            class auto_scale(TUIMethod):
                """
                Automatically compute x/y-axis extents?.
                """
            class background_color(TUIMethod):
                """
                Set the color of the plot background.
                """
            class end_plot_to_file(TUIMethod):
                """
                End plot to file.
                """
            class file_lines(TUIMethod):
                """
                Set parameters for plot lines.
                """
            class file_markers(TUIMethod):
                """
                Set parameters for data markers.
                """
            class get_residuals_window(TUIMethod):
                """
                Get residuals window id.
                """
            class key(TUIMethod):
                """
                Enable/disable display of curve key and set its window title.
                """
            class labels(TUIMethod):
                """
                Set labels for plot axes.
                """
            class lines(TUIMethod):
                """
                Set parameters for plot lines.
                """
            class log(TUIMethod):
                """
                Use log scales for one or both axes?.
                """
            class markers(TUIMethod):
                """
                Set parameters for data markers.
                """
            class numbers(TUIMethod):
                """
                Set number formats for axes.
                """
            class plot_to_file(TUIMethod):
                """
                Specify a file to write an xy plot to.
                """
            class rules(TUIMethod):
                """
                Set parameters for display of major and minor rules.
                """
            class windows(TUIMethod):
                """
                X-Y plot window options.
                """
            class xy_percent_y(TUIMethod):
                """
                Scale xy plot by percentage of total elements.
                """

        class flamelet_curves(TUIMenu):
            """
            Plot flamelet curves.
            """
            def __init__(self, service, version, mode, path):
                self.plot_curves = self.__class__.plot_curves(service, version, mode, path + ["plot_curves"])
                self.write_to_file = self.__class__.write_to_file(service, version, mode, path + ["write_to_file"])
                super().__init__(service, version, mode, path)
            class plot_curves(TUIMethod):
                """
                Plot of a property.
                """
            class write_to_file(TUIMethod):
                """
                Write curve to a file instead of plot.
                """

        class histogram_set(TUIMenu):
            """
            Enter the menu to set histogram plot parameters.
            """
            def __init__(self, service, version, mode, path):
                self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
                self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                self.end_plot_to_file = self.__class__.end_plot_to_file(service, version, mode, path + ["end_plot_to_file"])
                self.file_lines = self.__class__.file_lines(service, version, mode, path + ["file_lines"])
                self.file_markers = self.__class__.file_markers(service, version, mode, path + ["file_markers"])
                self.get_residuals_window = self.__class__.get_residuals_window(service, version, mode, path + ["get_residuals_window"])
                self.key = self.__class__.key(service, version, mode, path + ["key"])
                self.labels = self.__class__.labels(service, version, mode, path + ["labels"])
                self.lines = self.__class__.lines(service, version, mode, path + ["lines"])
                self.log = self.__class__.log(service, version, mode, path + ["log"])
                self.markers = self.__class__.markers(service, version, mode, path + ["markers"])
                self.numbers = self.__class__.numbers(service, version, mode, path + ["numbers"])
                self.plot_to_file = self.__class__.plot_to_file(service, version, mode, path + ["plot_to_file"])
                self.rules = self.__class__.rules(service, version, mode, path + ["rules"])
                self.windows = self.__class__.windows(service, version, mode, path + ["windows"])
                self.xy_percent_y = self.__class__.xy_percent_y(service, version, mode, path + ["xy_percent_y"])
                super().__init__(service, version, mode, path)
            class auto_scale(TUIMethod):
                """
                Automatically compute x/y-axis extents?.
                """
            class background_color(TUIMethod):
                """
                Set the color of the plot background.
                """
            class end_plot_to_file(TUIMethod):
                """
                End plot to file.
                """
            class file_lines(TUIMethod):
                """
                Set parameters for plot lines.
                """
            class file_markers(TUIMethod):
                """
                Set parameters for data markers.
                """
            class get_residuals_window(TUIMethod):
                """
                Get residuals window id.
                """
            class key(TUIMethod):
                """
                Enable/disable display of curve key and set its window title.
                """
            class labels(TUIMethod):
                """
                Set labels for plot axes.
                """
            class lines(TUIMethod):
                """
                Set parameters for plot lines.
                """
            class log(TUIMethod):
                """
                Use log scales for one or both axes?.
                """
            class markers(TUIMethod):
                """
                Set parameters for data markers.
                """
            class numbers(TUIMethod):
                """
                Set number formats for axes.
                """
            class plot_to_file(TUIMethod):
                """
                Specify a file to write an xy plot to.
                """
            class rules(TUIMethod):
                """
                Set parameters for display of major and minor rules.
                """
            class windows(TUIMethod):
                """
                X-Y plot window options.
                """
            class xy_percent_y(TUIMethod):
                """
                Scale xy plot by percentage of total elements.
                """

        class residuals_set(TUIMenu):
            """
            Enter the menu to set residual plot parameters.
            """
            def __init__(self, service, version, mode, path):
                self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
                self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                self.end_plot_to_file = self.__class__.end_plot_to_file(service, version, mode, path + ["end_plot_to_file"])
                self.file_lines = self.__class__.file_lines(service, version, mode, path + ["file_lines"])
                self.file_markers = self.__class__.file_markers(service, version, mode, path + ["file_markers"])
                self.get_residuals_window = self.__class__.get_residuals_window(service, version, mode, path + ["get_residuals_window"])
                self.key = self.__class__.key(service, version, mode, path + ["key"])
                self.labels = self.__class__.labels(service, version, mode, path + ["labels"])
                self.lines = self.__class__.lines(service, version, mode, path + ["lines"])
                self.log = self.__class__.log(service, version, mode, path + ["log"])
                self.markers = self.__class__.markers(service, version, mode, path + ["markers"])
                self.numbers = self.__class__.numbers(service, version, mode, path + ["numbers"])
                self.plot_to_file = self.__class__.plot_to_file(service, version, mode, path + ["plot_to_file"])
                self.rules = self.__class__.rules(service, version, mode, path + ["rules"])
                self.windows = self.__class__.windows(service, version, mode, path + ["windows"])
                self.xy_percent_y = self.__class__.xy_percent_y(service, version, mode, path + ["xy_percent_y"])
                super().__init__(service, version, mode, path)
            class auto_scale(TUIMethod):
                """
                Automatically compute x/y-axis extents?.
                """
            class background_color(TUIMethod):
                """
                Set the color of the plot background.
                """
            class end_plot_to_file(TUIMethod):
                """
                End plot to file.
                """
            class file_lines(TUIMethod):
                """
                Set parameters for plot lines.
                """
            class file_markers(TUIMethod):
                """
                Set parameters for data markers.
                """
            class get_residuals_window(TUIMethod):
                """
                Get residuals window id.
                """
            class key(TUIMethod):
                """
                Enable/disable display of curve key and set its window title.
                """
            class labels(TUIMethod):
                """
                Set labels for plot axes.
                """
            class lines(TUIMethod):
                """
                Set parameters for plot lines.
                """
            class log(TUIMethod):
                """
                Use log scales for one or both axes?.
                """
            class markers(TUIMethod):
                """
                Set parameters for data markers.
                """
            class numbers(TUIMethod):
                """
                Set number formats for axes.
                """
            class plot_to_file(TUIMethod):
                """
                Specify a file to write an xy plot to.
                """
            class rules(TUIMethod):
                """
                Set parameters for display of major and minor rules.
                """
            class windows(TUIMethod):
                """
                X-Y plot window options.
                """
            class xy_percent_y(TUIMethod):
                """
                Scale xy plot by percentage of total elements.
                """

        class solution_set(TUIMenu):
            """
            Enter the menu to set solution plot parameters.
            """
            def __init__(self, service, version, mode, path):
                self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
                self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                self.end_plot_to_file = self.__class__.end_plot_to_file(service, version, mode, path + ["end_plot_to_file"])
                self.file_lines = self.__class__.file_lines(service, version, mode, path + ["file_lines"])
                self.file_markers = self.__class__.file_markers(service, version, mode, path + ["file_markers"])
                self.get_residuals_window = self.__class__.get_residuals_window(service, version, mode, path + ["get_residuals_window"])
                self.key = self.__class__.key(service, version, mode, path + ["key"])
                self.labels = self.__class__.labels(service, version, mode, path + ["labels"])
                self.lines = self.__class__.lines(service, version, mode, path + ["lines"])
                self.log = self.__class__.log(service, version, mode, path + ["log"])
                self.markers = self.__class__.markers(service, version, mode, path + ["markers"])
                self.numbers = self.__class__.numbers(service, version, mode, path + ["numbers"])
                self.plot_to_file = self.__class__.plot_to_file(service, version, mode, path + ["plot_to_file"])
                self.rules = self.__class__.rules(service, version, mode, path + ["rules"])
                self.windows = self.__class__.windows(service, version, mode, path + ["windows"])
                self.xy_percent_y = self.__class__.xy_percent_y(service, version, mode, path + ["xy_percent_y"])
                super().__init__(service, version, mode, path)
            class auto_scale(TUIMethod):
                """
                Automatically compute x/y-axis extents?.
                """
            class background_color(TUIMethod):
                """
                Set the color of the plot background.
                """
            class end_plot_to_file(TUIMethod):
                """
                End plot to file.
                """
            class file_lines(TUIMethod):
                """
                Set parameters for plot lines.
                """
            class file_markers(TUIMethod):
                """
                Set parameters for data markers.
                """
            class get_residuals_window(TUIMethod):
                """
                Get residuals window id.
                """
            class key(TUIMethod):
                """
                Enable/disable display of curve key and set its window title.
                """
            class labels(TUIMethod):
                """
                Set labels for plot axes.
                """
            class lines(TUIMethod):
                """
                Set parameters for plot lines.
                """
            class log(TUIMethod):
                """
                Use log scales for one or both axes?.
                """
            class markers(TUIMethod):
                """
                Set parameters for data markers.
                """
            class numbers(TUIMethod):
                """
                Set number formats for axes.
                """
            class plot_to_file(TUIMethod):
                """
                Specify a file to write an xy plot to.
                """
            class rules(TUIMethod):
                """
                Set parameters for display of major and minor rules.
                """
            class windows(TUIMethod):
                """
                X-Y plot window options.
                """
            class xy_percent_y(TUIMethod):
                """
                Scale xy plot by percentage of total elements.
                """

        class vrx_sound_analysis(TUIMenu):
            """
            Ansys Sound analysis and specification.
            """
            def __init__(self, service, version, mode, path):
                self.print_indicators = self.__class__.print_indicators(service, version, mode, path + ["print_indicators"])
                self.write_files = self.__class__.write_files(service, version, mode, path + ["write_files"])
                super().__init__(service, version, mode, path)
            class print_indicators(TUIMethod):
                """
                Print Ansys Sound indicators.
                """
            class write_files(TUIMethod):
                """
                Write Ansys Sound out files.
                """

    class preferences(TUIMenu):
        """
        Set preferences.
        """
        def __init__(self, service, version, mode, path):
            self.appearance = self.__class__.appearance(service, version, mode, path + ["appearance"])
            self.general = self.__class__.general(service, version, mode, path + ["general"])
            self.gpuapp = self.__class__.gpuapp(service, version, mode, path + ["gpuapp"])
            self.graphics = self.__class__.graphics(service, version, mode, path + ["graphics"])
            self.mat_pro_app = self.__class__.mat_pro_app(service, version, mode, path + ["mat_pro_app"])
            self.meshing_workflow = self.__class__.meshing_workflow(service, version, mode, path + ["meshing_workflow"])
            self.navigation = self.__class__.navigation(service, version, mode, path + ["navigation"])
            self.parametric_study = self.__class__.parametric_study(service, version, mode, path + ["parametric_study"])
            self.prj_app = self.__class__.prj_app(service, version, mode, path + ["prj_app"])
            self.python_console = self.__class__.python_console(service, version, mode, path + ["python_console"])
            self.simulation = self.__class__.simulation(service, version, mode, path + ["simulation"])
            self.turbo_workflow = self.__class__.turbo_workflow(service, version, mode, path + ["turbo_workflow"])
            super().__init__(service, version, mode, path)

        class appearance(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.ansys_logo = self.__class__.ansys_logo(service, version, mode, path + ["ansys_logo"])
                self.charts = self.__class__.charts(service, version, mode, path + ["charts"])
                self.selections = self.__class__.selections(service, version, mode, path + ["selections"])
                self.allow_interface_bounds_flags = self.__class__.allow_interface_bounds_flags(service, version, mode, path + ["allow_interface_bounds_flags"])
                self.application_font_size = self.__class__.application_font_size(service, version, mode, path + ["application_font_size"])
                self.axis_triad = self.__class__.axis_triad(service, version, mode, path + ["axis_triad"])
                self.color_theme = self.__class__.color_theme(service, version, mode, path + ["color_theme"])
                self.completer = self.__class__.completer(service, version, mode, path + ["completer"])
                self.custom_title_bar = self.__class__.custom_title_bar(service, version, mode, path + ["custom_title_bar"])
                self.default_view = self.__class__.default_view(service, version, mode, path + ["default_view"])
                self.graphics_background_color1 = self.__class__.graphics_background_color1(service, version, mode, path + ["graphics_background_color1"])
                self.graphics_background_color2 = self.__class__.graphics_background_color2(service, version, mode, path + ["graphics_background_color2"])
                self.graphics_background_style = self.__class__.graphics_background_style(service, version, mode, path + ["graphics_background_style"])
                self.graphics_color_theme = self.__class__.graphics_color_theme(service, version, mode, path + ["graphics_color_theme"])
                self.graphics_default_manual_face_color = self.__class__.graphics_default_manual_face_color(service, version, mode, path + ["graphics_default_manual_face_color"])
                self.graphics_default_manual_node_color = self.__class__.graphics_default_manual_node_color(service, version, mode, path + ["graphics_default_manual_node_color"])
                self.graphics_edge_color = self.__class__.graphics_edge_color(service, version, mode, path + ["graphics_edge_color"])
                self.graphics_foreground_color = self.__class__.graphics_foreground_color(service, version, mode, path + ["graphics_foreground_color"])
                self.graphics_partition_boundary_color = self.__class__.graphics_partition_boundary_color(service, version, mode, path + ["graphics_partition_boundary_color"])
                self.graphics_surface_color = self.__class__.graphics_surface_color(service, version, mode, path + ["graphics_surface_color"])
                self.graphics_title_window_framecolor = self.__class__.graphics_title_window_framecolor(service, version, mode, path + ["graphics_title_window_framecolor"])
                self.graphics_view = self.__class__.graphics_view(service, version, mode, path + ["graphics_view"])
                self.graphics_wall_face_color = self.__class__.graphics_wall_face_color(service, version, mode, path + ["graphics_wall_face_color"])
                self.group_by_tree_view = self.__class__.group_by_tree_view(service, version, mode, path + ["group_by_tree_view"])
                self.group_physics_by_tree_view = self.__class__.group_physics_by_tree_view(service, version, mode, path + ["group_physics_by_tree_view"])
                self.model_color_scheme = self.__class__.model_color_scheme(service, version, mode, path + ["model_color_scheme"])
                self.number_of_files_recently_used = self.__class__.number_of_files_recently_used(service, version, mode, path + ["number_of_files_recently_used"])
                self.number_of_pastel_colors = self.__class__.number_of_pastel_colors(service, version, mode, path + ["number_of_pastel_colors"])
                self.pastel_color_saturation = self.__class__.pastel_color_saturation(service, version, mode, path + ["pastel_color_saturation"])
                self.pastel_color_value = self.__class__.pastel_color_value(service, version, mode, path + ["pastel_color_value"])
                self.quick_property_view = self.__class__.quick_property_view(service, version, mode, path + ["quick_property_view"])
                self.ruler = self.__class__.ruler(service, version, mode, path + ["ruler"])
                self.show_enabled_models = self.__class__.show_enabled_models(service, version, mode, path + ["show_enabled_models"])
                self.show_interface_non_overlapping_boundaries = self.__class__.show_interface_non_overlapping_boundaries(service, version, mode, path + ["show_interface_non_overlapping_boundaries"])
                self.show_model_edges = self.__class__.show_model_edges(service, version, mode, path + ["show_model_edges"])
                self.solution_mode_edge_color_in_meshing_mode = self.__class__.solution_mode_edge_color_in_meshing_mode(service, version, mode, path + ["solution_mode_edge_color_in_meshing_mode"])
                self.surface_emissivity = self.__class__.surface_emissivity(service, version, mode, path + ["surface_emissivity"])
                self.surface_specularity = self.__class__.surface_specularity(service, version, mode, path + ["surface_specularity"])
                self.surface_specularity_for_contours = self.__class__.surface_specularity_for_contours(service, version, mode, path + ["surface_specularity_for_contours"])
                self.titles = self.__class__.titles(service, version, mode, path + ["titles"])
                self.titles_border_offset = self.__class__.titles_border_offset(service, version, mode, path + ["titles_border_offset"])
                super().__init__(service, version, mode, path)
            class allow_interface_bounds_flags(TUIMethod):
                """
                .
                """
            class application_font_size(TUIMethod):
                """
                .
                """
            class axis_triad(TUIMethod):
                """
                .
                """
            class color_theme(TUIMethod):
                """
                .
                """
            class completer(TUIMethod):
                """
                .
                """
            class custom_title_bar(TUIMethod):
                """
                .
                """
            class default_view(TUIMethod):
                """
                .
                """
            class graphics_background_color1(TUIMethod):
                """
                .
                """
            class graphics_background_color2(TUIMethod):
                """
                .
                """
            class graphics_background_style(TUIMethod):
                """
                .
                """
            class graphics_color_theme(TUIMethod):
                """
                .
                """
            class graphics_default_manual_face_color(TUIMethod):
                """
                .
                """
            class graphics_default_manual_node_color(TUIMethod):
                """
                .
                """
            class graphics_edge_color(TUIMethod):
                """
                .
                """
            class graphics_foreground_color(TUIMethod):
                """
                .
                """
            class graphics_partition_boundary_color(TUIMethod):
                """
                .
                """
            class graphics_surface_color(TUIMethod):
                """
                .
                """
            class graphics_title_window_framecolor(TUIMethod):
                """
                .
                """
            class graphics_view(TUIMethod):
                """
                .
                """
            class graphics_wall_face_color(TUIMethod):
                """
                .
                """
            class group_by_tree_view(TUIMethod):
                """
                .
                """
            class group_physics_by_tree_view(TUIMethod):
                """
                .
                """
            class model_color_scheme(TUIMethod):
                """
                .
                """
            class number_of_files_recently_used(TUIMethod):
                """
                .
                """
            class number_of_pastel_colors(TUIMethod):
                """
                .
                """
            class pastel_color_saturation(TUIMethod):
                """
                .
                """
            class pastel_color_value(TUIMethod):
                """
                .
                """
            class quick_property_view(TUIMethod):
                """
                .
                """
            class ruler(TUIMethod):
                """
                .
                """
            class show_enabled_models(TUIMethod):
                """
                .
                """
            class show_interface_non_overlapping_boundaries(TUIMethod):
                """
                .
                """
            class show_model_edges(TUIMethod):
                """
                .
                """
            class solution_mode_edge_color_in_meshing_mode(TUIMethod):
                """
                .
                """
            class surface_emissivity(TUIMethod):
                """
                .
                """
            class surface_specularity(TUIMethod):
                """
                .
                """
            class surface_specularity_for_contours(TUIMethod):
                """
                .
                """
            class titles(TUIMethod):
                """
                .
                """
            class titles_border_offset(TUIMethod):
                """
                .
                """

            class ansys_logo(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.color = self.__class__.color(service, version, mode, path + ["color"])
                    self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                    super().__init__(service, version, mode, path)
                class color(TUIMethod):
                    """
                    .
                    """
                class visible(TUIMethod):
                    """
                    .
                    """

            class charts(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.font = self.__class__.font(service, version, mode, path + ["font"])
                    self.text_color = self.__class__.text_color(service, version, mode, path + ["text_color"])
                    self.curve_colors = self.__class__.curve_colors(service, version, mode, path + ["curve_colors"])
                    self.enable_open_glfor_modern_plots = self.__class__.enable_open_glfor_modern_plots(service, version, mode, path + ["enable_open_glfor_modern_plots"])
                    self.legend_alignment = self.__class__.legend_alignment(service, version, mode, path + ["legend_alignment"])
                    self.legend_visibility = self.__class__.legend_visibility(service, version, mode, path + ["legend_visibility"])
                    self.modern_plots_enabled = self.__class__.modern_plots_enabled(service, version, mode, path + ["modern_plots_enabled"])
                    self.modern_plots_points_threshold = self.__class__.modern_plots_points_threshold(service, version, mode, path + ["modern_plots_points_threshold"])
                    self.plots_behavior = self.__class__.plots_behavior(service, version, mode, path + ["plots_behavior"])
                    self.print_plot_data = self.__class__.print_plot_data(service, version, mode, path + ["print_plot_data"])
                    self.print_residuals_data = self.__class__.print_residuals_data(service, version, mode, path + ["print_residuals_data"])
                    self.threshold = self.__class__.threshold(service, version, mode, path + ["threshold"])
                    self.tooltip_interpolation = self.__class__.tooltip_interpolation(service, version, mode, path + ["tooltip_interpolation"])
                    super().__init__(service, version, mode, path)
                class curve_colors(TUIMethod):
                    """
                    .
                    """
                class enable_open_glfor_modern_plots(TUIMethod):
                    """
                    .
                    """
                class legend_alignment(TUIMethod):
                    """
                    .
                    """
                class legend_visibility(TUIMethod):
                    """
                    .
                    """
                class modern_plots_enabled(TUIMethod):
                    """
                    .
                    """
                class modern_plots_points_threshold(TUIMethod):
                    """
                    .
                    """
                class plots_behavior(TUIMethod):
                    """
                    .
                    """
                class print_plot_data(TUIMethod):
                    """
                    .
                    """
                class print_residuals_data(TUIMethod):
                    """
                    .
                    """
                class threshold(TUIMethod):
                    """
                    .
                    """
                class tooltip_interpolation(TUIMethod):
                    """
                    .
                    """

                class font(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                        self.axes_titles = self.__class__.axes_titles(service, version, mode, path + ["axes_titles"])
                        self.legend = self.__class__.legend(service, version, mode, path + ["legend"])
                        self.title = self.__class__.title(service, version, mode, path + ["title"])
                        super().__init__(service, version, mode, path)
                    class axes(TUIMethod):
                        """
                        .
                        """
                    class axes_titles(TUIMethod):
                        """
                        .
                        """
                    class legend(TUIMethod):
                        """
                        .
                        """
                    class title(TUIMethod):
                        """
                        .
                        """

                class text_color(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                        self.axes_titles = self.__class__.axes_titles(service, version, mode, path + ["axes_titles"])
                        self.legend = self.__class__.legend(service, version, mode, path + ["legend"])
                        self.title = self.__class__.title(service, version, mode, path + ["title"])
                        super().__init__(service, version, mode, path)
                    class axes(TUIMethod):
                        """
                        .
                        """
                    class axes_titles(TUIMethod):
                        """
                        .
                        """
                    class legend(TUIMethod):
                        """
                        .
                        """
                    class title(TUIMethod):
                        """
                        .
                        """

            class selections(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.enable_highlight_edge_transparency = self.__class__.enable_highlight_edge_transparency(service, version, mode, path + ["enable_highlight_edge_transparency"])
                    self.general_displacement = self.__class__.general_displacement(service, version, mode, path + ["general_displacement"])
                    self.highlight_edge_color = self.__class__.highlight_edge_color(service, version, mode, path + ["highlight_edge_color"])
                    self.highlight_edge_weight = self.__class__.highlight_edge_weight(service, version, mode, path + ["highlight_edge_weight"])
                    self.highlight_face_color = self.__class__.highlight_face_color(service, version, mode, path + ["highlight_face_color"])
                    self.highlight_gloss = self.__class__.highlight_gloss(service, version, mode, path + ["highlight_gloss"])
                    self.highlight_specular_component = self.__class__.highlight_specular_component(service, version, mode, path + ["highlight_specular_component"])
                    self.highlight_transparency = self.__class__.highlight_transparency(service, version, mode, path + ["highlight_transparency"])
                    self.mouse_hover_probe_values_enabled = self.__class__.mouse_hover_probe_values_enabled(service, version, mode, path + ["mouse_hover_probe_values_enabled"])
                    self.mouse_over_highlight_enabled = self.__class__.mouse_over_highlight_enabled(service, version, mode, path + ["mouse_over_highlight_enabled"])
                    self.probe_tooltip_hide_delay_timer = self.__class__.probe_tooltip_hide_delay_timer(service, version, mode, path + ["probe_tooltip_hide_delay_timer"])
                    self.probe_tooltip_show_delay_timer = self.__class__.probe_tooltip_show_delay_timer(service, version, mode, path + ["probe_tooltip_show_delay_timer"])
                    super().__init__(service, version, mode, path)
                class enable_highlight_edge_transparency(TUIMethod):
                    """
                    .
                    """
                class general_displacement(TUIMethod):
                    """
                    .
                    """
                class highlight_edge_color(TUIMethod):
                    """
                    .
                    """
                class highlight_edge_weight(TUIMethod):
                    """
                    .
                    """
                class highlight_face_color(TUIMethod):
                    """
                    .
                    """
                class highlight_gloss(TUIMethod):
                    """
                    .
                    """
                class highlight_specular_component(TUIMethod):
                    """
                    .
                    """
                class highlight_transparency(TUIMethod):
                    """
                    .
                    """
                class mouse_hover_probe_values_enabled(TUIMethod):
                    """
                    .
                    """
                class mouse_over_highlight_enabled(TUIMethod):
                    """
                    .
                    """
                class probe_tooltip_hide_delay_timer(TUIMethod):
                    """
                    .
                    """
                class probe_tooltip_show_delay_timer(TUIMethod):
                    """
                    .
                    """

        class general(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.startup_messages = self.__class__.startup_messages(service, version, mode, path + ["startup_messages"])
                self.advanced_partition = self.__class__.advanced_partition(service, version, mode, path + ["advanced_partition"])
                self.automatic_transcript = self.__class__.automatic_transcript(service, version, mode, path + ["automatic_transcript"])
                self.default_ioformat = self.__class__.default_ioformat(service, version, mode, path + ["default_ioformat"])
                self.dock_editor = self.__class__.dock_editor(service, version, mode, path + ["dock_editor"])
                self.flow_model = self.__class__.flow_model(service, version, mode, path + ["flow_model"])
                self.idle_timeout = self.__class__.idle_timeout(service, version, mode, path + ["idle_timeout"])
                self.import_physics_volume_definitions = self.__class__.import_physics_volume_definitions(service, version, mode, path + ["import_physics_volume_definitions"])
                self.initial_physics_volume_definitions = self.__class__.initial_physics_volume_definitions(service, version, mode, path + ["initial_physics_volume_definitions"])
                self.skip_creation_of_groups_pointing_to_single_entity = self.__class__.skip_creation_of_groups_pointing_to_single_entity(service, version, mode, path + ["skip_creation_of_groups_pointing_to_single_entity"])
                self.utlcreate_physics_on_mode_change = self.__class__.utlcreate_physics_on_mode_change(service, version, mode, path + ["utlcreate_physics_on_mode_change"])
                self.utlmode = self.__class__.utlmode(service, version, mode, path + ["utlmode"])
                super().__init__(service, version, mode, path)
            class advanced_partition(TUIMethod):
                """
                .
                """
            class automatic_transcript(TUIMethod):
                """
                .
                """
            class default_ioformat(TUIMethod):
                """
                .
                """
            class dock_editor(TUIMethod):
                """
                .
                """
            class flow_model(TUIMethod):
                """
                .
                """
            class idle_timeout(TUIMethod):
                """
                .
                """
            class import_physics_volume_definitions(TUIMethod):
                """
                .
                """
            class initial_physics_volume_definitions(TUIMethod):
                """
                .
                """
            class skip_creation_of_groups_pointing_to_single_entity(TUIMethod):
                """
                .
                """
            class utlcreate_physics_on_mode_change(TUIMethod):
                """
                .
                """
            class utlmode(TUIMethod):
                """
                .
                """

            class startup_messages(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.color_theme_change_message = self.__class__.color_theme_change_message(service, version, mode, path + ["color_theme_change_message"])
                    self.key_behavioral_changes_message = self.__class__.key_behavioral_changes_message(service, version, mode, path + ["key_behavioral_changes_message"])
                    self.qaservice_message = self.__class__.qaservice_message(service, version, mode, path + ["qaservice_message"])
                    super().__init__(service, version, mode, path)
                class color_theme_change_message(TUIMethod):
                    """
                    .
                    """
                class key_behavioral_changes_message(TUIMethod):
                    """
                    .
                    """
                class qaservice_message(TUIMethod):
                    """
                    .
                    """

        class gpuapp(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.alpha_features = self.__class__.alpha_features(service, version, mode, path + ["alpha_features"])
                super().__init__(service, version, mode, path)
            class alpha_features(TUIMethod):
                """
                .
                """

        class graphics(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.boundary_markers = self.__class__.boundary_markers(service, version, mode, path + ["boundary_markers"])
                self.colormap_settings = self.__class__.colormap_settings(service, version, mode, path + ["colormap_settings"])
                self.display_lists = self.__class__.display_lists(service, version, mode, path + ["display_lists"])
                self.embedded_windows = self.__class__.embedded_windows(service, version, mode, path + ["embedded_windows"])
                self.export_video_settings = self.__class__.export_video_settings(service, version, mode, path + ["export_video_settings"])
                self.graphics_effects = self.__class__.graphics_effects(service, version, mode, path + ["graphics_effects"])
                self.hardcopy_settings = self.__class__.hardcopy_settings(service, version, mode, path + ["hardcopy_settings"])
                self.lighting = self.__class__.lighting(service, version, mode, path + ["lighting"])
                self.manage_hoops_memory = self.__class__.manage_hoops_memory(service, version, mode, path + ["manage_hoops_memory"])
                self.material_effects = self.__class__.material_effects(service, version, mode, path + ["material_effects"])
                self.meshing_mode = self.__class__.meshing_mode(service, version, mode, path + ["meshing_mode"])
                self.performance = self.__class__.performance(service, version, mode, path + ["performance"])
                self.ray_tracing_options = self.__class__.ray_tracing_options(service, version, mode, path + ["ray_tracing_options"])
                self.transparency = self.__class__.transparency(service, version, mode, path + ["transparency"])
                self.vector_settings = self.__class__.vector_settings(service, version, mode, path + ["vector_settings"])
                self.animation_option = self.__class__.animation_option(service, version, mode, path + ["animation_option"])
                self.backface_cull = self.__class__.backface_cull(service, version, mode, path + ["backface_cull"])
                self.camera_near_limit = self.__class__.camera_near_limit(service, version, mode, path + ["camera_near_limit"])
                self.double_buffering = self.__class__.double_buffering(service, version, mode, path + ["double_buffering"])
                self.enable_camera_near_limit_to_avoid_zfighting = self.__class__.enable_camera_near_limit_to_avoid_zfighting(service, version, mode, path + ["enable_camera_near_limit_to_avoid_zfighting"])
                self.enable_non_object_based_workflow = self.__class__.enable_non_object_based_workflow(service, version, mode, path + ["enable_non_object_based_workflow"])
                self.event_poll_interval = self.__class__.event_poll_interval(service, version, mode, path + ["event_poll_interval"])
                self.event_poll_timeout = self.__class__.event_poll_timeout(service, version, mode, path + ["event_poll_timeout"])
                self.force_key_frame_animation_markers_to_off = self.__class__.force_key_frame_animation_markers_to_off(service, version, mode, path + ["force_key_frame_animation_markers_to_off"])
                self.graphics_window_line_width = self.__class__.graphics_window_line_width(service, version, mode, path + ["graphics_window_line_width"])
                self.graphics_window_point_symbol = self.__class__.graphics_window_point_symbol(service, version, mode, path + ["graphics_window_point_symbol"])
                self.hidden_surface_removal_method = self.__class__.hidden_surface_removal_method(service, version, mode, path + ["hidden_surface_removal_method"])
                self.higher_resolution_graphics_window_line_width = self.__class__.higher_resolution_graphics_window_line_width(service, version, mode, path + ["higher_resolution_graphics_window_line_width"])
                self.lower_resolution_graphics_window_line_width = self.__class__.lower_resolution_graphics_window_line_width(service, version, mode, path + ["lower_resolution_graphics_window_line_width"])
                self.marker_drawing_mode = self.__class__.marker_drawing_mode(service, version, mode, path + ["marker_drawing_mode"])
                self.max_graphics_text_size = self.__class__.max_graphics_text_size(service, version, mode, path + ["max_graphics_text_size"])
                self.min_graphics_text_size = self.__class__.min_graphics_text_size(service, version, mode, path + ["min_graphics_text_size"])
                self.plot_legend_margin = self.__class__.plot_legend_margin(service, version, mode, path + ["plot_legend_margin"])
                self.point_tool_size = self.__class__.point_tool_size(service, version, mode, path + ["point_tool_size"])
                self.remove_partition_lines = self.__class__.remove_partition_lines(service, version, mode, path + ["remove_partition_lines"])
                self.remove_partition_lines_tolerance = self.__class__.remove_partition_lines_tolerance(service, version, mode, path + ["remove_partition_lines_tolerance"])
                self.rotation_centerpoint_visible = self.__class__.rotation_centerpoint_visible(service, version, mode, path + ["rotation_centerpoint_visible"])
                self.scroll_wheel_event_end_timer = self.__class__.scroll_wheel_event_end_timer(service, version, mode, path + ["scroll_wheel_event_end_timer"])
                self.selection_highlight_window = self.__class__.selection_highlight_window(service, version, mode, path + ["selection_highlight_window"])
                self.set_camera_normal_to_surface_increments = self.__class__.set_camera_normal_to_surface_increments(service, version, mode, path + ["set_camera_normal_to_surface_increments"])
                self.show_hidden_lines = self.__class__.show_hidden_lines(service, version, mode, path + ["show_hidden_lines"])
                self.show_hidden_surfaces = self.__class__.show_hidden_surfaces(service, version, mode, path + ["show_hidden_surfaces"])
                self.surface_general_displacement = self.__class__.surface_general_displacement(service, version, mode, path + ["surface_general_displacement"])
                self.switch_to_open_glfor_remote_visualization = self.__class__.switch_to_open_glfor_remote_visualization(service, version, mode, path + ["switch_to_open_glfor_remote_visualization"])
                self.test_use_external_function = self.__class__.test_use_external_function(service, version, mode, path + ["test_use_external_function"])
                self.text_window_line_width = self.__class__.text_window_line_width(service, version, mode, path + ["text_window_line_width"])
                super().__init__(service, version, mode, path)
            class animation_option(TUIMethod):
                """
                .
                """
            class backface_cull(TUIMethod):
                """
                .
                """
            class camera_near_limit(TUIMethod):
                """
                .
                """
            class double_buffering(TUIMethod):
                """
                .
                """
            class enable_camera_near_limit_to_avoid_zfighting(TUIMethod):
                """
                .
                """
            class enable_non_object_based_workflow(TUIMethod):
                """
                .
                """
            class event_poll_interval(TUIMethod):
                """
                .
                """
            class event_poll_timeout(TUIMethod):
                """
                .
                """
            class force_key_frame_animation_markers_to_off(TUIMethod):
                """
                .
                """
            class graphics_window_line_width(TUIMethod):
                """
                .
                """
            class graphics_window_point_symbol(TUIMethod):
                """
                .
                """
            class hidden_surface_removal_method(TUIMethod):
                """
                .
                """
            class higher_resolution_graphics_window_line_width(TUIMethod):
                """
                .
                """
            class lower_resolution_graphics_window_line_width(TUIMethod):
                """
                .
                """
            class marker_drawing_mode(TUIMethod):
                """
                .
                """
            class max_graphics_text_size(TUIMethod):
                """
                .
                """
            class min_graphics_text_size(TUIMethod):
                """
                .
                """
            class plot_legend_margin(TUIMethod):
                """
                .
                """
            class point_tool_size(TUIMethod):
                """
                .
                """
            class remove_partition_lines(TUIMethod):
                """
                .
                """
            class remove_partition_lines_tolerance(TUIMethod):
                """
                .
                """
            class rotation_centerpoint_visible(TUIMethod):
                """
                .
                """
            class scroll_wheel_event_end_timer(TUIMethod):
                """
                .
                """
            class selection_highlight_window(TUIMethod):
                """
                .
                """
            class set_camera_normal_to_surface_increments(TUIMethod):
                """
                .
                """
            class show_hidden_lines(TUIMethod):
                """
                .
                """
            class show_hidden_surfaces(TUIMethod):
                """
                .
                """
            class surface_general_displacement(TUIMethod):
                """
                .
                """
            class switch_to_open_glfor_remote_visualization(TUIMethod):
                """
                .
                """
            class test_use_external_function(TUIMethod):
                """
                .
                """
            class text_window_line_width(TUIMethod):
                """
                .
                """

            class boundary_markers(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.automatic_marker_scaling = self.__class__.automatic_marker_scaling(service, version, mode, path + ["automatic_marker_scaling"])
                    self.color_option = self.__class__.color_option(service, version, mode, path + ["color_option"])
                    self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                    self.exclude_from_bounding = self.__class__.exclude_from_bounding(service, version, mode, path + ["exclude_from_bounding"])
                    self.inlet_color = self.__class__.inlet_color(service, version, mode, path + ["inlet_color"])
                    self.marker_fraction = self.__class__.marker_fraction(service, version, mode, path + ["marker_fraction"])
                    self.marker_size_limiting_scale_multiplier = self.__class__.marker_size_limiting_scale_multiplier(service, version, mode, path + ["marker_size_limiting_scale_multiplier"])
                    self.markers_limit = self.__class__.markers_limit(service, version, mode, path + ["markers_limit"])
                    self.outlet_color = self.__class__.outlet_color(service, version, mode, path + ["outlet_color"])
                    self.scale_marker = self.__class__.scale_marker(service, version, mode, path + ["scale_marker"])
                    self.show_inlet_markers = self.__class__.show_inlet_markers(service, version, mode, path + ["show_inlet_markers"])
                    self.show_outlet_markers = self.__class__.show_outlet_markers(service, version, mode, path + ["show_outlet_markers"])
                    super().__init__(service, version, mode, path)
                class automatic_marker_scaling(TUIMethod):
                    """
                    .
                    """
                class color_option(TUIMethod):
                    """
                    .
                    """
                class enabled(TUIMethod):
                    """
                    .
                    """
                class exclude_from_bounding(TUIMethod):
                    """
                    .
                    """
                class inlet_color(TUIMethod):
                    """
                    .
                    """
                class marker_fraction(TUIMethod):
                    """
                    .
                    """
                class marker_size_limiting_scale_multiplier(TUIMethod):
                    """
                    .
                    """
                class markers_limit(TUIMethod):
                    """
                    .
                    """
                class outlet_color(TUIMethod):
                    """
                    .
                    """
                class scale_marker(TUIMethod):
                    """
                    .
                    """
                class show_inlet_markers(TUIMethod):
                    """
                    .
                    """
                class show_outlet_markers(TUIMethod):
                    """
                    .
                    """

            class colormap_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.alignment = self.__class__.alignment(service, version, mode, path + ["alignment"])
                    self.aspect_ratio_when_horizontal = self.__class__.aspect_ratio_when_horizontal(service, version, mode, path + ["aspect_ratio_when_horizontal"])
                    self.aspect_ratio_when_vertical = self.__class__.aspect_ratio_when_vertical(service, version, mode, path + ["aspect_ratio_when_vertical"])
                    self.auto_refit_on_resize = self.__class__.auto_refit_on_resize(service, version, mode, path + ["auto_refit_on_resize"])
                    self.automatic_resize = self.__class__.automatic_resize(service, version, mode, path + ["automatic_resize"])
                    self.border_style = self.__class__.border_style(service, version, mode, path + ["border_style"])
                    self.colormap = self.__class__.colormap(service, version, mode, path + ["colormap"])
                    self.isolines_position_offset = self.__class__.isolines_position_offset(service, version, mode, path + ["isolines_position_offset"])
                    self.labels = self.__class__.labels(service, version, mode, path + ["labels"])
                    self.levels = self.__class__.levels(service, version, mode, path + ["levels"])
                    self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                    self.major_length_to_screen_ratio_when_horizontal = self.__class__.major_length_to_screen_ratio_when_horizontal(service, version, mode, path + ["major_length_to_screen_ratio_when_horizontal"])
                    self.major_length_to_screen_ratio_when_vertical = self.__class__.major_length_to_screen_ratio_when_vertical(service, version, mode, path + ["major_length_to_screen_ratio_when_vertical"])
                    self.margin_from_edge_to_screen_ratio = self.__class__.margin_from_edge_to_screen_ratio(service, version, mode, path + ["margin_from_edge_to_screen_ratio"])
                    self.max_size_scale_factor = self.__class__.max_size_scale_factor(service, version, mode, path + ["max_size_scale_factor"])
                    self.min_size_scale_factor = self.__class__.min_size_scale_factor(service, version, mode, path + ["min_size_scale_factor"])
                    self.number_format_precision = self.__class__.number_format_precision(service, version, mode, path + ["number_format_precision"])
                    self.number_format_type = self.__class__.number_format_type(service, version, mode, path + ["number_format_type"])
                    self.preserve_aspect_ratio_for_hardcopy = self.__class__.preserve_aspect_ratio_for_hardcopy(service, version, mode, path + ["preserve_aspect_ratio_for_hardcopy"])
                    self.show_colormap = self.__class__.show_colormap(service, version, mode, path + ["show_colormap"])
                    self.skip_value = self.__class__.skip_value(service, version, mode, path + ["skip_value"])
                    self.text_behavior = self.__class__.text_behavior(service, version, mode, path + ["text_behavior"])
                    self.text_font_automatic_horizontal_size = self.__class__.text_font_automatic_horizontal_size(service, version, mode, path + ["text_font_automatic_horizontal_size"])
                    self.text_font_automatic_size = self.__class__.text_font_automatic_size(service, version, mode, path + ["text_font_automatic_size"])
                    self.text_font_automatic_units = self.__class__.text_font_automatic_units(service, version, mode, path + ["text_font_automatic_units"])
                    self.text_font_automatic_vertical_size = self.__class__.text_font_automatic_vertical_size(service, version, mode, path + ["text_font_automatic_vertical_size"])
                    self.text_font_fixed_horizontal_size = self.__class__.text_font_fixed_horizontal_size(service, version, mode, path + ["text_font_fixed_horizontal_size"])
                    self.text_font_fixed_size = self.__class__.text_font_fixed_size(service, version, mode, path + ["text_font_fixed_size"])
                    self.text_font_fixed_units = self.__class__.text_font_fixed_units(service, version, mode, path + ["text_font_fixed_units"])
                    self.text_font_fixed_vertical_size = self.__class__.text_font_fixed_vertical_size(service, version, mode, path + ["text_font_fixed_vertical_size"])
                    self.text_font_name = self.__class__.text_font_name(service, version, mode, path + ["text_font_name"])
                    self.text_truncation_limit_for_horizontal_colormaps = self.__class__.text_truncation_limit_for_horizontal_colormaps(service, version, mode, path + ["text_truncation_limit_for_horizontal_colormaps"])
                    self.text_truncation_limit_for_vertical_colormaps = self.__class__.text_truncation_limit_for_vertical_colormaps(service, version, mode, path + ["text_truncation_limit_for_vertical_colormaps"])
                    self.type = self.__class__.type(service, version, mode, path + ["type"])
                    self.use_no_sub_windows = self.__class__.use_no_sub_windows(service, version, mode, path + ["use_no_sub_windows"])
                    super().__init__(service, version, mode, path)
                class alignment(TUIMethod):
                    """
                    .
                    """
                class aspect_ratio_when_horizontal(TUIMethod):
                    """
                    .
                    """
                class aspect_ratio_when_vertical(TUIMethod):
                    """
                    .
                    """
                class auto_refit_on_resize(TUIMethod):
                    """
                    .
                    """
                class automatic_resize(TUIMethod):
                    """
                    .
                    """
                class border_style(TUIMethod):
                    """
                    .
                    """
                class colormap(TUIMethod):
                    """
                    .
                    """
                class isolines_position_offset(TUIMethod):
                    """
                    .
                    """
                class labels(TUIMethod):
                    """
                    .
                    """
                class levels(TUIMethod):
                    """
                    .
                    """
                class log_scale(TUIMethod):
                    """
                    .
                    """
                class major_length_to_screen_ratio_when_horizontal(TUIMethod):
                    """
                    .
                    """
                class major_length_to_screen_ratio_when_vertical(TUIMethod):
                    """
                    .
                    """
                class margin_from_edge_to_screen_ratio(TUIMethod):
                    """
                    .
                    """
                class max_size_scale_factor(TUIMethod):
                    """
                    .
                    """
                class min_size_scale_factor(TUIMethod):
                    """
                    .
                    """
                class number_format_precision(TUIMethod):
                    """
                    .
                    """
                class number_format_type(TUIMethod):
                    """
                    .
                    """
                class preserve_aspect_ratio_for_hardcopy(TUIMethod):
                    """
                    .
                    """
                class show_colormap(TUIMethod):
                    """
                    .
                    """
                class skip_value(TUIMethod):
                    """
                    .
                    """
                class text_behavior(TUIMethod):
                    """
                    .
                    """
                class text_font_automatic_horizontal_size(TUIMethod):
                    """
                    .
                    """
                class text_font_automatic_size(TUIMethod):
                    """
                    .
                    """
                class text_font_automatic_units(TUIMethod):
                    """
                    .
                    """
                class text_font_automatic_vertical_size(TUIMethod):
                    """
                    .
                    """
                class text_font_fixed_horizontal_size(TUIMethod):
                    """
                    .
                    """
                class text_font_fixed_size(TUIMethod):
                    """
                    .
                    """
                class text_font_fixed_units(TUIMethod):
                    """
                    .
                    """
                class text_font_fixed_vertical_size(TUIMethod):
                    """
                    .
                    """
                class text_font_name(TUIMethod):
                    """
                    .
                    """
                class text_truncation_limit_for_horizontal_colormaps(TUIMethod):
                    """
                    .
                    """
                class text_truncation_limit_for_vertical_colormaps(TUIMethod):
                    """
                    .
                    """
                class type(TUIMethod):
                    """
                    .
                    """
                class use_no_sub_windows(TUIMethod):
                    """
                    .
                    """

            class display_lists(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.options = self.__class__.options(service, version, mode, path + ["options"])
                    super().__init__(service, version, mode, path)
                class options(TUIMethod):
                    """
                    .
                    """

            class embedded_windows(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.default_embedded_mesh_windows_view = self.__class__.default_embedded_mesh_windows_view(service, version, mode, path + ["default_embedded_mesh_windows_view"])
                    self.default_embedded_windows_view = self.__class__.default_embedded_windows_view(service, version, mode, path + ["default_embedded_windows_view"])
                    self.save_embedded_window_layout = self.__class__.save_embedded_window_layout(service, version, mode, path + ["save_embedded_window_layout"])
                    self.show_border_for_embedded_window = self.__class__.show_border_for_embedded_window(service, version, mode, path + ["show_border_for_embedded_window"])
                    super().__init__(service, version, mode, path)
                class default_embedded_mesh_windows_view(TUIMethod):
                    """
                    .
                    """
                class default_embedded_windows_view(TUIMethod):
                    """
                    .
                    """
                class save_embedded_window_layout(TUIMethod):
                    """
                    .
                    """
                class show_border_for_embedded_window(TUIMethod):
                    """
                    .
                    """

            class export_video_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.advanced_video_quality_options = self.__class__.advanced_video_quality_options(service, version, mode, path + ["advanced_video_quality_options"])
                    self.video_format = self.__class__.video_format(service, version, mode, path + ["video_format"])
                    self.video_fps = self.__class__.video_fps(service, version, mode, path + ["video_fps"])
                    self.video_quality = self.__class__.video_quality(service, version, mode, path + ["video_quality"])
                    self.video_resoution_x = self.__class__.video_resoution_x(service, version, mode, path + ["video_resoution_x"])
                    self.video_resoution_y = self.__class__.video_resoution_y(service, version, mode, path + ["video_resoution_y"])
                    self.video_scale = self.__class__.video_scale(service, version, mode, path + ["video_scale"])
                    self.video_smooth_scaling = self.__class__.video_smooth_scaling(service, version, mode, path + ["video_smooth_scaling"])
                    self.video_use_frame_resolution = self.__class__.video_use_frame_resolution(service, version, mode, path + ["video_use_frame_resolution"])
                    super().__init__(service, version, mode, path)
                class video_format(TUIMethod):
                    """
                    .
                    """
                class video_fps(TUIMethod):
                    """
                    .
                    """
                class video_quality(TUIMethod):
                    """
                    .
                    """
                class video_resoution_x(TUIMethod):
                    """
                    .
                    """
                class video_resoution_y(TUIMethod):
                    """
                    .
                    """
                class video_scale(TUIMethod):
                    """
                    .
                    """
                class video_smooth_scaling(TUIMethod):
                    """
                    .
                    """
                class video_use_frame_resolution(TUIMethod):
                    """
                    .
                    """

                class advanced_video_quality_options(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.bit_rate_quality = self.__class__.bit_rate_quality(service, version, mode, path + ["bit_rate_quality"])
                        self.bitrate = self.__class__.bitrate(service, version, mode, path + ["bitrate"])
                        self.compression_method = self.__class__.compression_method(service, version, mode, path + ["compression_method"])
                        self.enable_h264 = self.__class__.enable_h264(service, version, mode, path + ["enable_h264"])
                        super().__init__(service, version, mode, path)
                    class bit_rate_quality(TUIMethod):
                        """
                        .
                        """
                    class bitrate(TUIMethod):
                        """
                        .
                        """
                    class compression_method(TUIMethod):
                        """
                        .
                        """
                    class enable_h264(TUIMethod):
                        """
                        .
                        """

            class graphics_effects(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.ambient_occlusion_enabled = self.__class__.ambient_occlusion_enabled(service, version, mode, path + ["ambient_occlusion_enabled"])
                    self.ambient_occlusion_quality = self.__class__.ambient_occlusion_quality(service, version, mode, path + ["ambient_occlusion_quality"])
                    self.ambient_occlusion_strength = self.__class__.ambient_occlusion_strength(service, version, mode, path + ["ambient_occlusion_strength"])
                    self.anti_aliasing = self.__class__.anti_aliasing(service, version, mode, path + ["anti_aliasing"])
                    self.bloom_blur = self.__class__.bloom_blur(service, version, mode, path + ["bloom_blur"])
                    self.bloom_enabled = self.__class__.bloom_enabled(service, version, mode, path + ["bloom_enabled"])
                    self.bloom_strength = self.__class__.bloom_strength(service, version, mode, path + ["bloom_strength"])
                    self.grid_color = self.__class__.grid_color(service, version, mode, path + ["grid_color"])
                    self.grid_plane_count = self.__class__.grid_plane_count(service, version, mode, path + ["grid_plane_count"])
                    self.grid_plane_enabled = self.__class__.grid_plane_enabled(service, version, mode, path + ["grid_plane_enabled"])
                    self.grid_plane_offset = self.__class__.grid_plane_offset(service, version, mode, path + ["grid_plane_offset"])
                    self.grid_plane_size_factor = self.__class__.grid_plane_size_factor(service, version, mode, path + ["grid_plane_size_factor"])
                    self.plane_direction = self.__class__.plane_direction(service, version, mode, path + ["plane_direction"])
                    self.reflections_enabled = self.__class__.reflections_enabled(service, version, mode, path + ["reflections_enabled"])
                    self.shadow_map_enabled = self.__class__.shadow_map_enabled(service, version, mode, path + ["shadow_map_enabled"])
                    self.show_edge_reflections = self.__class__.show_edge_reflections(service, version, mode, path + ["show_edge_reflections"])
                    self.show_marker_reflections = self.__class__.show_marker_reflections(service, version, mode, path + ["show_marker_reflections"])
                    self.simple_shadows_enabled = self.__class__.simple_shadows_enabled(service, version, mode, path + ["simple_shadows_enabled"])
                    self.update_after_mouse_release = self.__class__.update_after_mouse_release(service, version, mode, path + ["update_after_mouse_release"])
                    super().__init__(service, version, mode, path)
                class ambient_occlusion_enabled(TUIMethod):
                    """
                    .
                    """
                class ambient_occlusion_quality(TUIMethod):
                    """
                    .
                    """
                class ambient_occlusion_strength(TUIMethod):
                    """
                    .
                    """
                class anti_aliasing(TUIMethod):
                    """
                    .
                    """
                class bloom_blur(TUIMethod):
                    """
                    .
                    """
                class bloom_enabled(TUIMethod):
                    """
                    .
                    """
                class bloom_strength(TUIMethod):
                    """
                    .
                    """
                class grid_color(TUIMethod):
                    """
                    .
                    """
                class grid_plane_count(TUIMethod):
                    """
                    .
                    """
                class grid_plane_enabled(TUIMethod):
                    """
                    .
                    """
                class grid_plane_offset(TUIMethod):
                    """
                    .
                    """
                class grid_plane_size_factor(TUIMethod):
                    """
                    .
                    """
                class plane_direction(TUIMethod):
                    """
                    .
                    """
                class reflections_enabled(TUIMethod):
                    """
                    .
                    """
                class shadow_map_enabled(TUIMethod):
                    """
                    .
                    """
                class show_edge_reflections(TUIMethod):
                    """
                    .
                    """
                class show_marker_reflections(TUIMethod):
                    """
                    .
                    """
                class simple_shadows_enabled(TUIMethod):
                    """
                    .
                    """
                class update_after_mouse_release(TUIMethod):
                    """
                    .
                    """

            class hardcopy_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.export_edges_for_avz = self.__class__.export_edges_for_avz(service, version, mode, path + ["export_edges_for_avz"])
                    self.hardcopy_driver = self.__class__.hardcopy_driver(service, version, mode, path + ["hardcopy_driver"])
                    self.hardcopy_line_width = self.__class__.hardcopy_line_width(service, version, mode, path + ["hardcopy_line_width"])
                    self.hardware_image_accel = self.__class__.hardware_image_accel(service, version, mode, path + ["hardware_image_accel"])
                    self.post_script_permission_override = self.__class__.post_script_permission_override(service, version, mode, path + ["post_script_permission_override"])
                    self.retain_colormap_pos_for_avz = self.__class__.retain_colormap_pos_for_avz(service, version, mode, path + ["retain_colormap_pos_for_avz"])
                    self.save_embedded_hardcopies_separately = self.__class__.save_embedded_hardcopies_separately(service, version, mode, path + ["save_embedded_hardcopies_separately"])
                    self.save_embedded_windows_in_hardcopy = self.__class__.save_embedded_windows_in_hardcopy(service, version, mode, path + ["save_embedded_windows_in_hardcopy"])
                    self.transparent_embedded_windows = self.__class__.transparent_embedded_windows(service, version, mode, path + ["transparent_embedded_windows"])
                    super().__init__(service, version, mode, path)
                class export_edges_for_avz(TUIMethod):
                    """
                    .
                    """
                class hardcopy_driver(TUIMethod):
                    """
                    .
                    """
                class hardcopy_line_width(TUIMethod):
                    """
                    .
                    """
                class hardware_image_accel(TUIMethod):
                    """
                    .
                    """
                class post_script_permission_override(TUIMethod):
                    """
                    .
                    """
                class retain_colormap_pos_for_avz(TUIMethod):
                    """
                    .
                    """
                class save_embedded_hardcopies_separately(TUIMethod):
                    """
                    .
                    """
                class save_embedded_windows_in_hardcopy(TUIMethod):
                    """
                    .
                    """
                class transparent_embedded_windows(TUIMethod):
                    """
                    .
                    """

            class lighting(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.ambient_light_intensity = self.__class__.ambient_light_intensity(service, version, mode, path + ["ambient_light_intensity"])
                    self.headlight = self.__class__.headlight(service, version, mode, path + ["headlight"])
                    self.headlight_intensity = self.__class__.headlight_intensity(service, version, mode, path + ["headlight_intensity"])
                    self.lighting_method = self.__class__.lighting_method(service, version, mode, path + ["lighting_method"])
                    super().__init__(service, version, mode, path)
                class ambient_light_intensity(TUIMethod):
                    """
                    .
                    """
                class headlight(TUIMethod):
                    """
                    .
                    """
                class headlight_intensity(TUIMethod):
                    """
                    .
                    """
                class lighting_method(TUIMethod):
                    """
                    .
                    """

            class manage_hoops_memory(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                    self.hsfimport_limit = self.__class__.hsfimport_limit(service, version, mode, path + ["hsfimport_limit"])
                    super().__init__(service, version, mode, path)
                class enabled(TUIMethod):
                    """
                    .
                    """
                class hsfimport_limit(TUIMethod):
                    """
                    .
                    """

            class material_effects(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.decimation_filter = self.__class__.decimation_filter(service, version, mode, path + ["decimation_filter"])
                    self.parameterization_source = self.__class__.parameterization_source(service, version, mode, path + ["parameterization_source"])
                    self.tiling_style = self.__class__.tiling_style(service, version, mode, path + ["tiling_style"])
                    super().__init__(service, version, mode, path)
                class decimation_filter(TUIMethod):
                    """
                    .
                    """
                class parameterization_source(TUIMethod):
                    """
                    .
                    """
                class tiling_style(TUIMethod):
                    """
                    .
                    """

            class meshing_mode(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.graphics_window_display_timeout = self.__class__.graphics_window_display_timeout(service, version, mode, path + ["graphics_window_display_timeout"])
                    self.graphics_window_display_timeout_value = self.__class__.graphics_window_display_timeout_value(service, version, mode, path + ["graphics_window_display_timeout_value"])
                    super().__init__(service, version, mode, path)
                class graphics_window_display_timeout(TUIMethod):
                    """
                    .
                    """
                class graphics_window_display_timeout_value(TUIMethod):
                    """
                    .
                    """

            class performance(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.fast_display_mode = self.__class__.fast_display_mode(service, version, mode, path + ["fast_display_mode"])
                    self.minimum_frame_rate = self.__class__.minimum_frame_rate(service, version, mode, path + ["minimum_frame_rate"])
                    self.optimize_input_data = self.__class__.optimize_input_data(service, version, mode, path + ["optimize_input_data"])
                    self.optimize_for = self.__class__.optimize_for(service, version, mode, path + ["optimize_for"])
                    self.ratio_of_target_frame_rate_to_classify_heavy_geometry = self.__class__.ratio_of_target_frame_rate_to_classify_heavy_geometry(service, version, mode, path + ["ratio_of_target_frame_rate_to_classify_heavy_geometry"])
                    self.ratio_of_target_frame_rate_to_declassify_heavy_geometry = self.__class__.ratio_of_target_frame_rate_to_declassify_heavy_geometry(service, version, mode, path + ["ratio_of_target_frame_rate_to_declassify_heavy_geometry"])
                    super().__init__(service, version, mode, path)
                class optimize_for(TUIMethod):
                    """
                    .
                    """
                class ratio_of_target_frame_rate_to_classify_heavy_geometry(TUIMethod):
                    """
                    .
                    """
                class ratio_of_target_frame_rate_to_declassify_heavy_geometry(TUIMethod):
                    """
                    .
                    """

                class fast_display_mode(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.culling = self.__class__.culling(service, version, mode, path + ["culling"])
                        self.faces_shown = self.__class__.faces_shown(service, version, mode, path + ["faces_shown"])
                        self.markers_decimation = self.__class__.markers_decimation(service, version, mode, path + ["markers_decimation"])
                        self.nodes_shown = self.__class__.nodes_shown(service, version, mode, path + ["nodes_shown"])
                        self.perimeter_edges_shown = self.__class__.perimeter_edges_shown(service, version, mode, path + ["perimeter_edges_shown"])
                        self.silhouette_shown = self.__class__.silhouette_shown(service, version, mode, path + ["silhouette_shown"])
                        self.status = self.__class__.status(service, version, mode, path + ["status"])
                        self.transparency = self.__class__.transparency(service, version, mode, path + ["transparency"])
                        super().__init__(service, version, mode, path)
                    class culling(TUIMethod):
                        """
                        .
                        """
                    class faces_shown(TUIMethod):
                        """
                        .
                        """
                    class markers_decimation(TUIMethod):
                        """
                        .
                        """
                    class nodes_shown(TUIMethod):
                        """
                        .
                        """
                    class perimeter_edges_shown(TUIMethod):
                        """
                        .
                        """
                    class silhouette_shown(TUIMethod):
                        """
                        .
                        """
                    class status(TUIMethod):
                        """
                        .
                        """
                    class transparency(TUIMethod):
                        """
                        .
                        """

                class minimum_frame_rate(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.dynamic_adjustment = self.__class__.dynamic_adjustment(service, version, mode, path + ["dynamic_adjustment"])
                        self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                        self.fixed_culling_value = self.__class__.fixed_culling_value(service, version, mode, path + ["fixed_culling_value"])
                        self.maximum_culling_threshold = self.__class__.maximum_culling_threshold(service, version, mode, path + ["maximum_culling_threshold"])
                        self.minimum_culling_threshold = self.__class__.minimum_culling_threshold(service, version, mode, path + ["minimum_culling_threshold"])
                        self.target_fps = self.__class__.target_fps(service, version, mode, path + ["target_fps"])
                        super().__init__(service, version, mode, path)
                    class dynamic_adjustment(TUIMethod):
                        """
                        .
                        """
                    class enabled(TUIMethod):
                        """
                        .
                        """
                    class fixed_culling_value(TUIMethod):
                        """
                        .
                        """
                    class maximum_culling_threshold(TUIMethod):
                        """
                        .
                        """
                    class minimum_culling_threshold(TUIMethod):
                        """
                        .
                        """
                    class target_fps(TUIMethod):
                        """
                        .
                        """

                class optimize_input_data(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                        self.maximum_facets_per_shell = self.__class__.maximum_facets_per_shell(service, version, mode, path + ["maximum_facets_per_shell"])
                        super().__init__(service, version, mode, path)
                    class enabled(TUIMethod):
                        """
                        .
                        """
                    class maximum_facets_per_shell(TUIMethod):
                        """
                        .
                        """

            class ray_tracing_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.volume_rendering_method = self.__class__.volume_rendering_method(service, version, mode, path + ["volume_rendering_method"])
                    super().__init__(service, version, mode, path)
                class volume_rendering_method(TUIMethod):
                    """
                    .
                    """

            class transparency(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.algorithm_for_modern_drivers = self.__class__.algorithm_for_modern_drivers(service, version, mode, path + ["algorithm_for_modern_drivers"])
                    self.depth_peeling_layers = self.__class__.depth_peeling_layers(service, version, mode, path + ["depth_peeling_layers"])
                    self.depth_peeling_preference = self.__class__.depth_peeling_preference(service, version, mode, path + ["depth_peeling_preference"])
                    self.quick_moves = self.__class__.quick_moves(service, version, mode, path + ["quick_moves"])
                    self.zsort_options = self.__class__.zsort_options(service, version, mode, path + ["zsort_options"])
                    super().__init__(service, version, mode, path)
                class algorithm_for_modern_drivers(TUIMethod):
                    """
                    .
                    """
                class depth_peeling_layers(TUIMethod):
                    """
                    .
                    """
                class depth_peeling_preference(TUIMethod):
                    """
                    .
                    """
                class quick_moves(TUIMethod):
                    """
                    .
                    """
                class zsort_options(TUIMethod):
                    """
                    .
                    """

            class vector_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.arrow3_dradius1_factor = self.__class__.arrow3_dradius1_factor(service, version, mode, path + ["arrow3_dradius1_factor"])
                    self.arrow3_dradius2_factor = self.__class__.arrow3_dradius2_factor(service, version, mode, path + ["arrow3_dradius2_factor"])
                    self.arrowhead3_dradius1_factor = self.__class__.arrowhead3_dradius1_factor(service, version, mode, path + ["arrowhead3_dradius1_factor"])
                    self.line_arrow3_dperpendicular_radius = self.__class__.line_arrow3_dperpendicular_radius(service, version, mode, path + ["line_arrow3_dperpendicular_radius"])
                    super().__init__(service, version, mode, path)
                class arrow3_dradius1_factor(TUIMethod):
                    """
                    .
                    """
                class arrow3_dradius2_factor(TUIMethod):
                    """
                    .
                    """
                class arrowhead3_dradius1_factor(TUIMethod):
                    """
                    .
                    """
                class line_arrow3_dperpendicular_radius(TUIMethod):
                    """
                    .
                    """

        class mat_pro_app(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.check_expression = self.__class__.check_expression(service, version, mode, path + ["check_expression"])
                self.statistics = self.__class__.statistics(service, version, mode, path + ["statistics"])
                self.beta_features = self.__class__.beta_features(service, version, mode, path + ["beta_features"])
                self.check_crash = self.__class__.check_crash(service, version, mode, path + ["check_crash"])
                self.debug = self.__class__.debug(service, version, mode, path + ["debug"])
                self.focus = self.__class__.focus(service, version, mode, path + ["focus"])
                self.mesh_naming = self.__class__.mesh_naming(service, version, mode, path + ["mesh_naming"])
                self.tracking = self.__class__.tracking(service, version, mode, path + ["tracking"])
                self.warning = self.__class__.warning(service, version, mode, path + ["warning"])
                super().__init__(service, version, mode, path)
            class beta_features(TUIMethod):
                """
                .
                """
            class check_crash(TUIMethod):
                """
                .
                """
            class debug(TUIMethod):
                """
                .
                """
            class focus(TUIMethod):
                """
                .
                """
            class mesh_naming(TUIMethod):
                """
                .
                """
            class tracking(TUIMethod):
                """
                .
                """
            class warning(TUIMethod):
                """
                .
                """

            class check_expression(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.cdot = self.__class__.cdot(service, version, mode, path + ["cdot"])
                    self.coordinates = self.__class__.coordinates(service, version, mode, path + ["coordinates"])
                    self.dvv = self.__class__.dvv(service, version, mode, path + ["dvv"])
                    self.edot = self.__class__.edot(service, version, mode, path + ["edot"])
                    self.gdot = self.__class__.gdot(service, version, mode, path + ["gdot"])
                    self.giesekus = self.__class__.giesekus(service, version, mode, path + ["giesekus"])
                    self.pressure = self.__class__.pressure(service, version, mode, path + ["pressure"])
                    self.species = self.__class__.species(service, version, mode, path + ["species"])
                    self.temperature = self.__class__.temperature(service, version, mode, path + ["temperature"])
                    self.time = self.__class__.time(service, version, mode, path + ["time"])
                    self.velocities = self.__class__.velocities(service, version, mode, path + ["velocities"])
                    self.vorticity = self.__class__.vorticity(service, version, mode, path + ["vorticity"])
                    super().__init__(service, version, mode, path)
                class cdot(TUIMethod):
                    """
                    .
                    """
                class coordinates(TUIMethod):
                    """
                    .
                    """
                class dvv(TUIMethod):
                    """
                    .
                    """
                class edot(TUIMethod):
                    """
                    .
                    """
                class gdot(TUIMethod):
                    """
                    .
                    """
                class giesekus(TUIMethod):
                    """
                    .
                    """
                class pressure(TUIMethod):
                    """
                    .
                    """
                class species(TUIMethod):
                    """
                    .
                    """
                class temperature(TUIMethod):
                    """
                    .
                    """
                class time(TUIMethod):
                    """
                    .
                    """
                class velocities(TUIMethod):
                    """
                    .
                    """
                class vorticity(TUIMethod):
                    """
                    .
                    """

            class statistics(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.max_positions = self.__class__.max_positions(service, version, mode, path + ["max_positions"])
                    self.quick_slicing = self.__class__.quick_slicing(service, version, mode, path + ["quick_slicing"])
                    super().__init__(service, version, mode, path)
                class max_positions(TUIMethod):
                    """
                    .
                    """
                class quick_slicing(TUIMethod):
                    """
                    .
                    """

        class meshing_workflow(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.draw_settings = self.__class__.draw_settings(service, version, mode, path + ["draw_settings"])
                self.checkpointing_option = self.__class__.checkpointing_option(service, version, mode, path + ["checkpointing_option"])
                self.save_checkpoint_files = self.__class__.save_checkpoint_files(service, version, mode, path + ["save_checkpoint_files"])
                self.save_wft_file_with_mesh = self.__class__.save_wft_file_with_mesh(service, version, mode, path + ["save_wft_file_with_mesh"])
                self.temp_folder = self.__class__.temp_folder(service, version, mode, path + ["temp_folder"])
                self.templates_folder = self.__class__.templates_folder(service, version, mode, path + ["templates_folder"])
                self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                super().__init__(service, version, mode, path)
            class checkpointing_option(TUIMethod):
                """
                .
                """
            class save_checkpoint_files(TUIMethod):
                """
                .
                """
            class save_wft_file_with_mesh(TUIMethod):
                """
                .
                """
            class temp_folder(TUIMethod):
                """
                .
                """
            class templates_folder(TUIMethod):
                """
                .
                """
            class verbosity(TUIMethod):
                """
                .
                """

            class draw_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.auto_draw = self.__class__.auto_draw(service, version, mode, path + ["auto_draw"])
                    self.face_zone_limit = self.__class__.face_zone_limit(service, version, mode, path + ["face_zone_limit"])
                    self.facet_limit = self.__class__.facet_limit(service, version, mode, path + ["facet_limit"])
                    super().__init__(service, version, mode, path)
                class auto_draw(TUIMethod):
                    """
                    .
                    """
                class face_zone_limit(TUIMethod):
                    """
                    .
                    """
                class facet_limit(TUIMethod):
                    """
                    .
                    """

        class navigation(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.mouse_mapping = self.__class__.mouse_mapping(service, version, mode, path + ["mouse_mapping"])
                super().__init__(service, version, mode, path)

            class mouse_mapping(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.additional = self.__class__.additional(service, version, mode, path + ["additional"])
                    self.basic = self.__class__.basic(service, version, mode, path + ["basic"])
                    self.mousemaptheme = self.__class__.mousemaptheme(service, version, mode, path + ["mousemaptheme"])
                    super().__init__(service, version, mode, path)
                class mousemaptheme(TUIMethod):
                    """
                    .
                    """

                class additional(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.ctrllmbclick = self.__class__.ctrllmbclick(service, version, mode, path + ["ctrllmbclick"])
                        self.ctrllmbdrag = self.__class__.ctrllmbdrag(service, version, mode, path + ["ctrllmbdrag"])
                        self.ctrlmmbclick = self.__class__.ctrlmmbclick(service, version, mode, path + ["ctrlmmbclick"])
                        self.ctrlmmbdrag = self.__class__.ctrlmmbdrag(service, version, mode, path + ["ctrlmmbdrag"])
                        self.ctrlrmbclick = self.__class__.ctrlrmbclick(service, version, mode, path + ["ctrlrmbclick"])
                        self.ctrlrmbdrag = self.__class__.ctrlrmbdrag(service, version, mode, path + ["ctrlrmbdrag"])
                        self.mouseprobe = self.__class__.mouseprobe(service, version, mode, path + ["mouseprobe"])
                        self.mousewheel = self.__class__.mousewheel(service, version, mode, path + ["mousewheel"])
                        self.mousewheelsensitivity = self.__class__.mousewheelsensitivity(service, version, mode, path + ["mousewheelsensitivity"])
                        self.reversewheeldirection = self.__class__.reversewheeldirection(service, version, mode, path + ["reversewheeldirection"])
                        self.shiftlmbclick = self.__class__.shiftlmbclick(service, version, mode, path + ["shiftlmbclick"])
                        self.shiftlmbdrag = self.__class__.shiftlmbdrag(service, version, mode, path + ["shiftlmbdrag"])
                        self.shiftmmbclick = self.__class__.shiftmmbclick(service, version, mode, path + ["shiftmmbclick"])
                        self.shiftmmbdrag = self.__class__.shiftmmbdrag(service, version, mode, path + ["shiftmmbdrag"])
                        self.shiftrmbclick = self.__class__.shiftrmbclick(service, version, mode, path + ["shiftrmbclick"])
                        self.shiftrmbdrag = self.__class__.shiftrmbdrag(service, version, mode, path + ["shiftrmbdrag"])
                        super().__init__(service, version, mode, path)
                    class ctrllmbclick(TUIMethod):
                        """
                        .
                        """
                    class ctrllmbdrag(TUIMethod):
                        """
                        .
                        """
                    class ctrlmmbclick(TUIMethod):
                        """
                        .
                        """
                    class ctrlmmbdrag(TUIMethod):
                        """
                        .
                        """
                    class ctrlrmbclick(TUIMethod):
                        """
                        .
                        """
                    class ctrlrmbdrag(TUIMethod):
                        """
                        .
                        """
                    class mouseprobe(TUIMethod):
                        """
                        .
                        """
                    class mousewheel(TUIMethod):
                        """
                        .
                        """
                    class mousewheelsensitivity(TUIMethod):
                        """
                        .
                        """
                    class reversewheeldirection(TUIMethod):
                        """
                        .
                        """
                    class shiftlmbclick(TUIMethod):
                        """
                        .
                        """
                    class shiftlmbdrag(TUIMethod):
                        """
                        .
                        """
                    class shiftmmbclick(TUIMethod):
                        """
                        .
                        """
                    class shiftmmbdrag(TUIMethod):
                        """
                        .
                        """
                    class shiftrmbclick(TUIMethod):
                        """
                        .
                        """
                    class shiftrmbdrag(TUIMethod):
                        """
                        .
                        """

                class basic(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.lmb = self.__class__.lmb(service, version, mode, path + ["lmb"])
                        self.lmbclick = self.__class__.lmbclick(service, version, mode, path + ["lmbclick"])
                        self.mmb = self.__class__.mmb(service, version, mode, path + ["mmb"])
                        self.mmbclick = self.__class__.mmbclick(service, version, mode, path + ["mmbclick"])
                        self.rmb = self.__class__.rmb(service, version, mode, path + ["rmb"])
                        self.rmbclick = self.__class__.rmbclick(service, version, mode, path + ["rmbclick"])
                        super().__init__(service, version, mode, path)
                    class lmb(TUIMethod):
                        """
                        .
                        """
                    class lmbclick(TUIMethod):
                        """
                        .
                        """
                    class mmb(TUIMethod):
                        """
                        .
                        """
                    class mmbclick(TUIMethod):
                        """
                        .
                        """
                    class rmb(TUIMethod):
                        """
                        .
                        """
                    class rmbclick(TUIMethod):
                        """
                        .
                        """

        class parametric_study(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.layout_options = self.__class__.layout_options(service, version, mode, path + ["layout_options"])
                self.update_options = self.__class__.update_options(service, version, mode, path + ["update_options"])
                super().__init__(service, version, mode, path)

            class layout_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.current_case_parameters = self.__class__.current_case_parameters(service, version, mode, path + ["current_case_parameters"])
                    self.parametric_study_tree = self.__class__.parametric_study_tree(service, version, mode, path + ["parametric_study_tree"])
                    super().__init__(service, version, mode, path)
                class current_case_parameters(TUIMethod):
                    """
                    .
                    """
                class parametric_study_tree(TUIMethod):
                    """
                    .
                    """

            class update_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.auto_refresh_time = self.__class__.auto_refresh_time(service, version, mode, path + ["auto_refresh_time"])
                    self.capture_sim_report_data = self.__class__.capture_sim_report_data(service, version, mode, path + ["capture_sim_report_data"])
                    self.enable_auto_refresh = self.__class__.enable_auto_refresh(service, version, mode, path + ["enable_auto_refresh"])
                    self.parameter_value_precision = self.__class__.parameter_value_precision(service, version, mode, path + ["parameter_value_precision"])
                    self.save_project_after_dpupdate = self.__class__.save_project_after_dpupdate(service, version, mode, path + ["save_project_after_dpupdate"])
                    self.write_data = self.__class__.write_data(service, version, mode, path + ["write_data"])
                    super().__init__(service, version, mode, path)
                class auto_refresh_time(TUIMethod):
                    """
                    .
                    """
                class capture_sim_report_data(TUIMethod):
                    """
                    .
                    """
                class enable_auto_refresh(TUIMethod):
                    """
                    .
                    """
                class parameter_value_precision(TUIMethod):
                    """
                    .
                    """
                class save_project_after_dpupdate(TUIMethod):
                    """
                    .
                    """
                class write_data(TUIMethod):
                    """
                    .
                    """

        class prj_app(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.advanced_flag = self.__class__.advanced_flag(service, version, mode, path + ["advanced_flag"])
                self.beta_flag = self.__class__.beta_flag(service, version, mode, path + ["beta_flag"])
                self.unit_system = self.__class__.unit_system(service, version, mode, path + ["unit_system"])
                super().__init__(service, version, mode, path)
            class advanced_flag(TUIMethod):
                """
                .
                """
            class beta_flag(TUIMethod):
                """
                .
                """
            class unit_system(TUIMethod):
                """
                .
                """

        class python_console(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.console_suggestion = self.__class__.console_suggestion(service, version, mode, path + ["console_suggestion"])
                self.console_suggestion_active_only = self.__class__.console_suggestion_active_only(service, version, mode, path + ["console_suggestion_active_only"])
                self.pretty_print_dict = self.__class__.pretty_print_dict(service, version, mode, path + ["pretty_print_dict"])
                self.quick_search_results_active_only = self.__class__.quick_search_results_active_only(service, version, mode, path + ["quick_search_results_active_only"])
                super().__init__(service, version, mode, path)
            class console_suggestion(TUIMethod):
                """
                .
                """
            class console_suggestion_active_only(TUIMethod):
                """
                .
                """
            class pretty_print_dict(TUIMethod):
                """
                .
                """
            class quick_search_results_active_only(TUIMethod):
                """
                .
                """

        class simulation(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.report_definitions = self.__class__.report_definitions(service, version, mode, path + ["report_definitions"])
                self.flow_model = self.__class__.flow_model(service, version, mode, path + ["flow_model"])
                self.local_residual_scaling = self.__class__.local_residual_scaling(service, version, mode, path + ["local_residual_scaling"])
                self.pdf_combustion_robust_numerics = self.__class__.pdf_combustion_robust_numerics(service, version, mode, path + ["pdf_combustion_robust_numerics"])
                super().__init__(service, version, mode, path)
            class flow_model(TUIMethod):
                """
                .
                """
            class local_residual_scaling(TUIMethod):
                """
                .
                """
            class pdf_combustion_robust_numerics(TUIMethod):
                """
                .
                """

            class report_definitions(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.automatic_plot_file = self.__class__.automatic_plot_file(service, version, mode, path + ["automatic_plot_file"])
                    self.report_plot_history_data_size = self.__class__.report_plot_history_data_size(service, version, mode, path + ["report_plot_history_data_size"])
                    super().__init__(service, version, mode, path)
                class automatic_plot_file(TUIMethod):
                    """
                    .
                    """
                class report_plot_history_data_size(TUIMethod):
                    """
                    .
                    """

        class turbo_workflow(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.face_zone_settings = self.__class__.face_zone_settings(service, version, mode, path + ["face_zone_settings"])
                self.graphics_settings = self.__class__.graphics_settings(service, version, mode, path + ["graphics_settings"])
                self.checkpointing_option = self.__class__.checkpointing_option(service, version, mode, path + ["checkpointing_option"])
                self.save_checkpoint_files = self.__class__.save_checkpoint_files(service, version, mode, path + ["save_checkpoint_files"])
                super().__init__(service, version, mode, path)
            class checkpointing_option(TUIMethod):
                """
                .
                """
            class save_checkpoint_files(TUIMethod):
                """
                .
                """

            class face_zone_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.blade_region = self.__class__.blade_region(service, version, mode, path + ["blade_region"])
                    self.fzsearch_order = self.__class__.fzsearch_order(service, version, mode, path + ["fzsearch_order"])
                    self.hub_region = self.__class__.hub_region(service, version, mode, path + ["hub_region"])
                    self.inlet_region = self.__class__.inlet_region(service, version, mode, path + ["inlet_region"])
                    self.interior_region = self.__class__.interior_region(service, version, mode, path + ["interior_region"])
                    self.outlet_region = self.__class__.outlet_region(service, version, mode, path + ["outlet_region"])
                    self.periodic1_region = self.__class__.periodic1_region(service, version, mode, path + ["periodic1_region"])
                    self.periodic2_region = self.__class__.periodic2_region(service, version, mode, path + ["periodic2_region"])
                    self.shroud_region = self.__class__.shroud_region(service, version, mode, path + ["shroud_region"])
                    self.symmetry_region = self.__class__.symmetry_region(service, version, mode, path + ["symmetry_region"])
                    self.tip1_region = self.__class__.tip1_region(service, version, mode, path + ["tip1_region"])
                    self.tip2_region = self.__class__.tip2_region(service, version, mode, path + ["tip2_region"])
                    super().__init__(service, version, mode, path)
                class blade_region(TUIMethod):
                    """
                    .
                    """
                class fzsearch_order(TUIMethod):
                    """
                    .
                    """
                class hub_region(TUIMethod):
                    """
                    .
                    """
                class inlet_region(TUIMethod):
                    """
                    .
                    """
                class interior_region(TUIMethod):
                    """
                    .
                    """
                class outlet_region(TUIMethod):
                    """
                    .
                    """
                class periodic1_region(TUIMethod):
                    """
                    .
                    """
                class periodic2_region(TUIMethod):
                    """
                    .
                    """
                class shroud_region(TUIMethod):
                    """
                    .
                    """
                class symmetry_region(TUIMethod):
                    """
                    .
                    """
                class tip1_region(TUIMethod):
                    """
                    .
                    """
                class tip2_region(TUIMethod):
                    """
                    .
                    """

            class graphics_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.auto_draw = self.__class__.auto_draw(service, version, mode, path + ["auto_draw"])
                    super().__init__(service, version, mode, path)
                class auto_draw(TUIMethod):
                    """
                    .
                    """

    class report(TUIMenu):
        """
        Enter the report menu.
        """
        def __init__(self, service, version, mode, path):
            self.dpm_histogram = self.__class__.dpm_histogram(service, version, mode, path + ["dpm_histogram"])
            self.efficiency = self.__class__.efficiency(service, version, mode, path + ["efficiency"])
            self.fluxes = self.__class__.fluxes(service, version, mode, path + ["fluxes"])
            self.forces = self.__class__.forces(service, version, mode, path + ["forces"])
            self.heat_exchanger = self.__class__.heat_exchanger(service, version, mode, path + ["heat_exchanger"])
            self.icing = self.__class__.icing(service, version, mode, path + ["icing"])
            self.modified_setting = self.__class__.modified_setting(service, version, mode, path + ["modified_setting"])
            self.population_balance = self.__class__.population_balance(service, version, mode, path + ["population_balance"])
            self.reference_values = self.__class__.reference_values(service, version, mode, path + ["reference_values"])
            self.simulation_reports = self.__class__.simulation_reports(service, version, mode, path + ["simulation_reports"])
            self.surface_integrals = self.__class__.surface_integrals(service, version, mode, path + ["surface_integrals"])
            self.system = self.__class__.system(service, version, mode, path + ["system"])
            self.volume_integrals = self.__class__.volume_integrals(service, version, mode, path + ["volume_integrals"])
            self.aero_optical_distortions = self.__class__.aero_optical_distortions(service, version, mode, path + ["aero_optical_distortions"])
            self.calc_exchange_data_on_zone_types = self.__class__.calc_exchange_data_on_zone_types(service, version, mode, path + ["calc_exchange_data_on_zone_types"])
            self.dpm_extended_summary = self.__class__.dpm_extended_summary(service, version, mode, path + ["dpm_extended_summary"])
            self.dpm_sample = self.__class__.dpm_sample(service, version, mode, path + ["dpm_sample"])
            self.dpm_sample_output_udf = self.__class__.dpm_sample_output_udf(service, version, mode, path + ["dpm_sample_output_udf"])
            self.dpm_sample_sort_file = self.__class__.dpm_sample_sort_file(service, version, mode, path + ["dpm_sample_sort_file"])
            self.dpm_summary = self.__class__.dpm_summary(service, version, mode, path + ["dpm_summary"])
            self.dpm_zone_summaries_per_injection = self.__class__.dpm_zone_summaries_per_injection(service, version, mode, path + ["dpm_zone_summaries_per_injection"])
            self.element_mass_flow = self.__class__.element_mass_flow(service, version, mode, path + ["element_mass_flow"])
            self.enable_exch_details_in_dpm_summ_rep = self.__class__.enable_exch_details_in_dpm_summ_rep(service, version, mode, path + ["enable_exch_details_in_dpm_summ_rep"])
            self.mphase_summary = self.__class__.mphase_summary(service, version, mode, path + ["mphase_summary"])
            self.particle_summary = self.__class__.particle_summary(service, version, mode, path + ["particle_summary"])
            self.path_line_summary = self.__class__.path_line_summary(service, version, mode, path + ["path_line_summary"])
            self.phasic_integrals_enabled = self.__class__.phasic_integrals_enabled(service, version, mode, path + ["phasic_integrals_enabled"])
            self.print_histogram = self.__class__.print_histogram(service, version, mode, path + ["print_histogram"])
            self.projected_surface_area = self.__class__.projected_surface_area(service, version, mode, path + ["projected_surface_area"])
            self.species_mass_flow = self.__class__.species_mass_flow(service, version, mode, path + ["species_mass_flow"])
            self.summary = self.__class__.summary(service, version, mode, path + ["summary"])
            self.uds_flow = self.__class__.uds_flow(service, version, mode, path + ["uds_flow"])
            self.virtual_blade_model = self.__class__.virtual_blade_model(service, version, mode, path + ["virtual_blade_model"])
            self.write_histogram = self.__class__.write_histogram(service, version, mode, path + ["write_histogram"])
            super().__init__(service, version, mode, path)
        class aero_optical_distortions(TUIMethod):
            """
            .
            """
        class calc_exchange_data_on_zone_types(TUIMethod):
            """
            .
            """
        class dpm_extended_summary(TUIMethod):
            """
            .
            """
        class dpm_sample(TUIMethod):
            """
            .
            """
        class dpm_sample_output_udf(TUIMethod):
            """
            .
            """
        class dpm_sample_sort_file(TUIMethod):
            """
            .
            """
        class dpm_summary(TUIMethod):
            """
            .
            """
        class dpm_zone_summaries_per_injection(TUIMethod):
            """
            .
            """
        class element_mass_flow(TUIMethod):
            """
            .
            """
        class enable_exch_details_in_dpm_summ_rep(TUIMethod):
            """
            .
            """
        class mphase_summary(TUIMethod):
            """
            .
            """
        class particle_summary(TUIMethod):
            """
            .
            """
        class path_line_summary(TUIMethod):
            """
            .
            """
        class phasic_integrals_enabled(TUIMethod):
            """
            .
            """
        class print_histogram(TUIMethod):
            """
            Print a histogram of a scalar quantity.
            """
        class projected_surface_area(TUIMethod):
            """
            .
            """
        class species_mass_flow(TUIMethod):
            """
            .
            """
        class summary(TUIMethod):
            """
            .
            """
        class uds_flow(TUIMethod):
            """
            .
            """
        class virtual_blade_model(TUIMethod):
            """
            .
            """
        class write_histogram(TUIMethod):
            """
            Write a histogram of a scalar quantity to a file.
            """

        class dpm_histogram(TUIMenu):
            """
            Enter the DPM histogram menu.
            """
            def __init__(self, service, version, mode, path):
                self.set = self.__class__.set(service, version, mode, path + ["set"])
                self.setup_reduction = self.__class__.setup_reduction(service, version, mode, path + ["setup_reduction"])
                self.compute_sample = self.__class__.compute_sample(service, version, mode, path + ["compute_sample"])
                self.delete_sample = self.__class__.delete_sample(service, version, mode, path + ["delete_sample"])
                self.list_samples = self.__class__.list_samples(service, version, mode, path + ["list_samples"])
                self.pick_sample_to_reduce = self.__class__.pick_sample_to_reduce(service, version, mode, path + ["pick_sample_to_reduce"])
                self.plot_sample = self.__class__.plot_sample(service, version, mode, path + ["plot_sample"])
                self.prep_dpm_sample_cont_plot_exprs = self.__class__.prep_dpm_sample_cont_plot_exprs(service, version, mode, path + ["prep_dpm_sample_cont_plot_exprs"])
                self.read_sample = self.__class__.read_sample(service, version, mode, path + ["read_sample"])
                self.reduce_picked_sample = self.__class__.reduce_picked_sample(service, version, mode, path + ["reduce_picked_sample"])
                self.write_sample = self.__class__.write_sample(service, version, mode, path + ["write_sample"])
                super().__init__(service, version, mode, path)
            class compute_sample(TUIMethod):
                """
                Compute minimum/maximum of a sample variable.
                """
            class delete_sample(TUIMethod):
                """
                Delete a sample from loaded sample list.
                """
            class list_samples(TUIMethod):
                """
                Show all samples in loaded sample list.
                """
            class pick_sample_to_reduce(TUIMethod):
                """
                Pick a sample for which to first set-up and then perform the data reduction.
                """
            class plot_sample(TUIMethod):
                """
                Plot a histogram of a loaded sample.
                """
            class prep_dpm_sample_cont_plot_exprs(TUIMethod):
                """
                Prepare named expressions from data in a DPM sample file (collected at a cut plane surface) for contour plotting.
                """
            class read_sample(TUIMethod):
                """
                Read a sample file and add it to the sample list.
                """
            class reduce_picked_sample(TUIMethod):
                """
                Reduce a sample after first picking it and setting up all data-reduction options and parameters.
                """
            class write_sample(TUIMethod):
                """
                Write a histogram of a loaded sample into a file.
                """

            class set(TUIMenu):
                """
                Enter the settings menu for the histogram.
                """
                def __init__(self, service, version, mode, path):
                    self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                    self.correlation = self.__class__.correlation(service, version, mode, path + ["correlation"])
                    self.cumulation_curve = self.__class__.cumulation_curve(service, version, mode, path + ["cumulation_curve"])
                    self.diameter_statistics = self.__class__.diameter_statistics(service, version, mode, path + ["diameter_statistics"])
                    self.histogram_mode = self.__class__.histogram_mode(service, version, mode, path + ["histogram_mode"])
                    self.logarithmic = self.__class__.logarithmic(service, version, mode, path + ["logarithmic"])
                    self.maximum = self.__class__.maximum(service, version, mode, path + ["maximum"])
                    self.minimum = self.__class__.minimum(service, version, mode, path + ["minimum"])
                    self.number_of_bins = self.__class__.number_of_bins(service, version, mode, path + ["number_of_bins"])
                    self.percentage = self.__class__.percentage(service, version, mode, path + ["percentage"])
                    self.variable_power_3 = self.__class__.variable_power_3(service, version, mode, path + ["variable_power_3"])
                    self.weighting = self.__class__.weighting(service, version, mode, path + ["weighting"])
                    super().__init__(service, version, mode, path)
                class auto_range(TUIMethod):
                    """
                    Automatically compute range of sampling variable for histogram plots.
                    """
                class correlation(TUIMethod):
                    """
                    Compute correlation of sampling variable with other variable.
                    """
                class cumulation_curve(TUIMethod):
                    """
                    Compute a cumulative curve for sampling variable or correlation variable when correlation? was specified.
                    """
                class diameter_statistics(TUIMethod):
                    """
                    Compute Rosin Rammler parameters, Sauter and other mean diameters.
                    Requires specification of diameter as sampling variable.
                    """
                class histogram_mode(TUIMethod):
                    """
                    Use bars for histogram plot or xy-style.
                    """
                class logarithmic(TUIMethod):
                    """
                    Use logarithmic scaling on the abscissa (variable axis)? -- Will not work unless all values are positive.
                    """
                class maximum(TUIMethod):
                    """
                    Specify maximum value of x-axis variable for histogram plots.
                    """
                class minimum(TUIMethod):
                    """
                    Specify mimimum value of x-axis variable for histogram plots.
                    """
                class number_of_bins(TUIMethod):
                    """
                    Specify the number of bins.
                    """
                class percentage(TUIMethod):
                    """
                    Use percentages of bins to be computed.
                    """
                class variable_power_3(TUIMethod):
                    """
                    Use the cubic of the cumulation variable during computation of the cumulative curve.
                    When the particle mass was not sampled, the diameter can be used instead.
                    """
                class weighting(TUIMethod):
                    """
                    Use weighting with additional variable when sorting data into samples.
                    """

            class setup_reduction(TUIMenu):
                """
                Set up the sample data reduction by specifying all relevant options and setting parameters as desired.
                """
                def __init__(self, service, version, mode, path):
                    self.all_variables_number_of_bins = self.__class__.all_variables_number_of_bins(service, version, mode, path + ["all_variables_number_of_bins"])
                    self.list_settings = self.__class__.list_settings(service, version, mode, path + ["list_settings"])
                    self.logarithmic = self.__class__.logarithmic(service, version, mode, path + ["logarithmic"])
                    self.make_steady_from_unsteady_file = self.__class__.make_steady_from_unsteady_file(service, version, mode, path + ["make_steady_from_unsteady_file"])
                    self.maximum = self.__class__.maximum(service, version, mode, path + ["maximum"])
                    self.minimum = self.__class__.minimum(service, version, mode, path + ["minimum"])
                    self.number_of_bins = self.__class__.number_of_bins(service, version, mode, path + ["number_of_bins"])
                    self.reset_min_and_max = self.__class__.reset_min_and_max(service, version, mode, path + ["reset_min_and_max"])
                    self.use_weighting = self.__class__.use_weighting(service, version, mode, path + ["use_weighting"])
                    self.weighting_variable = self.__class__.weighting_variable(service, version, mode, path + ["weighting_variable"])
                    super().__init__(service, version, mode, path)
                class all_variables_number_of_bins(TUIMethod):
                    """
                    Set the number of bins to be used for ALL variables in the data reduction.
                    """
                class list_settings(TUIMethod):
                    """
                    List all user inputs for the sample picked for data reduction.
                    """
                class logarithmic(TUIMethod):
                    """
                    Switch on or off logarithmic scaling to be used for a specific variable in the data reduction.
                    """
                class make_steady_from_unsteady_file(TUIMethod):
                    """
                    Specify whether the unsteady sample is to be reduced into a steady-state injection file.
                    """
                class maximum(TUIMethod):
                    """
                    Set the maximum value of the range to be considered for a specific variable in the data reduction.
                    """
                class minimum(TUIMethod):
                    """
                    Set the minimum value of the range to be considered for a specific variable in the data reduction.
                    """
                class number_of_bins(TUIMethod):
                    """
                    Set the number of bins to be used for a specific variable in the data reduction.
                    """
                class reset_min_and_max(TUIMethod):
                    """
                    Reset the min and max values of the range to be considered for a specific variable in the data reduction.
                    """
                class use_weighting(TUIMethod):
                    """
                    Specify whether to use any weighting in the averaging that is done in each bin in the data reduction.
                    """
                class weighting_variable(TUIMethod):
                    """
                    Choose the weighting variable for the averaging in each bin in the data reduction.
                    """

        class efficiency(TUIMenu):
            """
            Enter the menu for efficiency computations.
            """
            def __init__(self, service, version, mode, path):
                self.isentropic = self.__class__.isentropic(service, version, mode, path + ["isentropic"])
                self.polytropic = self.__class__.polytropic(service, version, mode, path + ["polytropic"])
                self.use_in_turbo_report = self.__class__.use_in_turbo_report(service, version, mode, path + ["use_in_turbo_report"])
                super().__init__(service, version, mode, path)
            class isentropic(TUIMethod):
                """
                Calculate isentropic efficiency.
                """
            class polytropic(TUIMethod):
                """
                Calculate polytropic efficiency.
                """
            class use_in_turbo_report(TUIMethod):
                """
                Use this general method instead of constant Cp-based to compute efficiency with Turbo Report tool.
                """

        class fluxes(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.electric_current = self.__class__.electric_current(service, version, mode, path + ["electric_current"])
                self.film_heat_transfer = self.__class__.film_heat_transfer(service, version, mode, path + ["film_heat_transfer"])
                self.film_mass_flow = self.__class__.film_mass_flow(service, version, mode, path + ["film_mass_flow"])
                self.heat_transfer = self.__class__.heat_transfer(service, version, mode, path + ["heat_transfer"])
                self.heat_transfer_sensible = self.__class__.heat_transfer_sensible(service, version, mode, path + ["heat_transfer_sensible"])
                self.mass_flow = self.__class__.mass_flow(service, version, mode, path + ["mass_flow"])
                self.pressure_work = self.__class__.pressure_work(service, version, mode, path + ["pressure_work"])
                self.rad_heat_trans = self.__class__.rad_heat_trans(service, version, mode, path + ["rad_heat_trans"])
                self.viscous_work = self.__class__.viscous_work(service, version, mode, path + ["viscous_work"])
                super().__init__(service, version, mode, path)
            class electric_current(TUIMethod):
                """
                .
                """
            class film_heat_transfer(TUIMethod):
                """
                .
                """
            class film_mass_flow(TUIMethod):
                """
                .
                """
            class heat_transfer(TUIMethod):
                """
                .
                """
            class heat_transfer_sensible(TUIMethod):
                """
                .
                """
            class mass_flow(TUIMethod):
                """
                .
                """
            class pressure_work(TUIMethod):
                """
                .
                """
            class rad_heat_trans(TUIMethod):
                """
                .
                """
            class viscous_work(TUIMethod):
                """
                .
                """

        class forces(TUIMenu):
            """
            Force report menu.
            """
            def __init__(self, service, version, mode, path):
                self.pressure_center = self.__class__.pressure_center(service, version, mode, path + ["pressure_center"])
                self.wall_forces = self.__class__.wall_forces(service, version, mode, path + ["wall_forces"])
                self.wall_moments = self.__class__.wall_moments(service, version, mode, path + ["wall_moments"])
                super().__init__(service, version, mode, path)
            class pressure_center(TUIMethod):
                """
                Print center of pressure on wall zones.
                """
            class wall_forces(TUIMethod):
                """
                Print integrated pressure and viscous forces on wall zones.
                """
            class wall_moments(TUIMethod):
                """
                Print integrated pressure and viscous moments on wall zones.
                """

        class heat_exchanger(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.computed_heat_rejection = self.__class__.computed_heat_rejection(service, version, mode, path + ["computed_heat_rejection"])
                self.inlet_temperature = self.__class__.inlet_temperature(service, version, mode, path + ["inlet_temperature"])
                self.mass_flow_rate = self.__class__.mass_flow_rate(service, version, mode, path + ["mass_flow_rate"])
                self.outlet_temperature = self.__class__.outlet_temperature(service, version, mode, path + ["outlet_temperature"])
                self.specific_heat = self.__class__.specific_heat(service, version, mode, path + ["specific_heat"])
                super().__init__(service, version, mode, path)
            class computed_heat_rejection(TUIMethod):
                """
                .
                """
            class inlet_temperature(TUIMethod):
                """
                .
                """
            class mass_flow_rate(TUIMethod):
                """
                .
                """
            class outlet_temperature(TUIMethod):
                """
                .
                """
            class specific_heat(TUIMethod):
                """
                .
                """

        class icing(TUIMenu):
            """
            Icing reports menu.
            """
            def __init__(self, service, version, mode, path):
                self.energy_of_ice_formation = self.__class__.energy_of_ice_formation(service, version, mode, path + ["energy_of_ice_formation"])
                self.energy_of_water_impinged = self.__class__.energy_of_water_impinged(service, version, mode, path + ["energy_of_water_impinged"])
                self.icing_energy_of_conduction = self.__class__.icing_energy_of_conduction(service, version, mode, path + ["icing_energy_of_conduction"])
                self.mass_of_ice = self.__class__.mass_of_ice(service, version, mode, path + ["mass_of_ice"])
                self.mass_of_water_impinged = self.__class__.mass_of_water_impinged(service, version, mode, path + ["mass_of_water_impinged"])
                self.particles_crystals_collection_eff = self.__class__.particles_crystals_collection_eff(service, version, mode, path + ["particles_crystals_collection_eff"])
                self.particles_droplets_collection_eff = self.__class__.particles_droplets_collection_eff(service, version, mode, path + ["particles_droplets_collection_eff"])
                super().__init__(service, version, mode, path)
            class energy_of_ice_formation(TUIMethod):
                """
                Print Energy of Ice Formation.
                """
            class energy_of_water_impinged(TUIMethod):
                """
                Print Energy of Water Impingement.
                """
            class icing_energy_of_conduction(TUIMethod):
                """
                Print Energy of Conduction.
                """
            class mass_of_ice(TUIMethod):
                """
                Print Mass of Ice Accretion.
                """
            class mass_of_water_impinged(TUIMethod):
                """
                Print Mass of Water Impingement.
                """
            class particles_crystals_collection_eff(TUIMethod):
                """
                Print Crystals Collection Efficiency.
                """
            class particles_droplets_collection_eff(TUIMethod):
                """
                Print Droplets Collection Efficiency.
                """

        class modified_setting(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.modified_setting = self.__class__.modified_setting(service, version, mode, path + ["modified_setting"])
                self.write_user_setting = self.__class__.write_user_setting(service, version, mode, path + ["write_user_setting"])
                super().__init__(service, version, mode, path)
            class modified_setting(TUIMethod):
                """
                .
                """
            class write_user_setting(TUIMethod):
                """
                .
                """

        class population_balance(TUIMenu):
            """
            Population Balance menu.
            """
            def __init__(self, service, version, mode, path):
                self.moments = self.__class__.moments(service, version, mode, path + ["moments"])
                self.number_density = self.__class__.number_density(service, version, mode, path + ["number_density"])
                super().__init__(service, version, mode, path)
            class moments(TUIMethod):
                """
                .
                """
            class number_density(TUIMethod):
                """
                Set number density functions.
                """

        class reference_values(TUIMenu):
            """
            Reference value menu.
            """
            def __init__(self, service, version, mode, path):
                self.compute = self.__class__.compute(service, version, mode, path + ["compute"])
                self.area = self.__class__.area(service, version, mode, path + ["area"])
                self.density = self.__class__.density(service, version, mode, path + ["density"])
                self.depth = self.__class__.depth(service, version, mode, path + ["depth"])
                self.enthalpy = self.__class__.enthalpy(service, version, mode, path + ["enthalpy"])
                self.length = self.__class__.length(service, version, mode, path + ["length"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.pressure = self.__class__.pressure(service, version, mode, path + ["pressure"])
                self.temperature = self.__class__.temperature(service, version, mode, path + ["temperature"])
                self.velocity = self.__class__.velocity(service, version, mode, path + ["velocity"])
                self.viscosity = self.__class__.viscosity(service, version, mode, path + ["viscosity"])
                self.yplus = self.__class__.yplus(service, version, mode, path + ["yplus"])
                self.zone = self.__class__.zone(service, version, mode, path + ["zone"])
                super().__init__(service, version, mode, path)
            class area(TUIMethod):
                """
                .
                """
            class density(TUIMethod):
                """
                .
                """
            class depth(TUIMethod):
                """
                .
                """
            class enthalpy(TUIMethod):
                """
                .
                """
            class length(TUIMethod):
                """
                .
                """
            class list(TUIMethod):
                """
                .
                """
            class pressure(TUIMethod):
                """
                .
                """
            class temperature(TUIMethod):
                """
                .
                """
            class velocity(TUIMethod):
                """
                .
                """
            class viscosity(TUIMethod):
                """
                .
                """
            class yplus(TUIMethod):
                """
                .
                """
            class zone(TUIMethod):
                """
                Set reference zone.
                """

            class compute(TUIMenu):
                """
                Enter the compute menu.
                """
                def __init__(self, service, version, mode, path):
                    self.axis = self.__class__.axis(service, version, mode, path + ["axis"])
                    self.degassing = self.__class__.degassing(service, version, mode, path + ["degassing"])
                    self.dummy_entry = self.__class__.dummy_entry(service, version, mode, path + ["dummy_entry"])
                    self.exhaust_fan = self.__class__.exhaust_fan(service, version, mode, path + ["exhaust_fan"])
                    self.fan = self.__class__.fan(service, version, mode, path + ["fan"])
                    self.fluid = self.__class__.fluid(service, version, mode, path + ["fluid"])
                    self.geometry = self.__class__.geometry(service, version, mode, path + ["geometry"])
                    self.inlet_vent = self.__class__.inlet_vent(service, version, mode, path + ["inlet_vent"])
                    self.intake_fan = self.__class__.intake_fan(service, version, mode, path + ["intake_fan"])
                    self.interface = self.__class__.interface(service, version, mode, path + ["interface"])
                    self.interior = self.__class__.interior(service, version, mode, path + ["interior"])
                    self.mass_flow_inlet = self.__class__.mass_flow_inlet(service, version, mode, path + ["mass_flow_inlet"])
                    self.mass_flow_outlet = self.__class__.mass_flow_outlet(service, version, mode, path + ["mass_flow_outlet"])
                    self.network = self.__class__.network(service, version, mode, path + ["network"])
                    self.network_end = self.__class__.network_end(service, version, mode, path + ["network_end"])
                    self.outflow = self.__class__.outflow(service, version, mode, path + ["outflow"])
                    self.outlet_vent = self.__class__.outlet_vent(service, version, mode, path + ["outlet_vent"])
                    self.overset = self.__class__.overset(service, version, mode, path + ["overset"])
                    self.periodic = self.__class__.periodic(service, version, mode, path + ["periodic"])
                    self.porous_jump = self.__class__.porous_jump(service, version, mode, path + ["porous_jump"])
                    self.pressure_far_field = self.__class__.pressure_far_field(service, version, mode, path + ["pressure_far_field"])
                    self.pressure_inlet = self.__class__.pressure_inlet(service, version, mode, path + ["pressure_inlet"])
                    self.pressure_outlet = self.__class__.pressure_outlet(service, version, mode, path + ["pressure_outlet"])
                    self.radiator = self.__class__.radiator(service, version, mode, path + ["radiator"])
                    self.rans_les_interface = self.__class__.rans_les_interface(service, version, mode, path + ["rans_les_interface"])
                    self.recirculation_inlet = self.__class__.recirculation_inlet(service, version, mode, path + ["recirculation_inlet"])
                    self.recirculation_outlet = self.__class__.recirculation_outlet(service, version, mode, path + ["recirculation_outlet"])
                    self.shadow = self.__class__.shadow(service, version, mode, path + ["shadow"])
                    self.solid = self.__class__.solid(service, version, mode, path + ["solid"])
                    self.symmetry = self.__class__.symmetry(service, version, mode, path + ["symmetry"])
                    self.velocity_inlet = self.__class__.velocity_inlet(service, version, mode, path + ["velocity_inlet"])
                    self.wall = self.__class__.wall(service, version, mode, path + ["wall"])
                    super().__init__(service, version, mode, path)
                class axis(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class degassing(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class dummy_entry(TUIMethod):
                    """
                    .
                    """
                class exhaust_fan(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class fan(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class fluid(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class geometry(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class inlet_vent(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class intake_fan(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class interface(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class interior(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class mass_flow_inlet(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class mass_flow_outlet(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class network(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class network_end(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class outflow(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class outlet_vent(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class overset(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class periodic(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class porous_jump(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class pressure_far_field(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class pressure_inlet(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class pressure_outlet(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class radiator(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class rans_les_interface(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class recirculation_inlet(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class recirculation_outlet(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class shadow(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class solid(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class symmetry(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class velocity_inlet(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """
                class wall(TUIMethod):
                    """
                    Compute reference values from a zone of this type.
                    """

        class simulation_reports(TUIMenu):
            """
            Enter the simulation reports menu.
            """
            def __init__(self, service, version, mode, path):
                self.parametric_study = self.__class__.parametric_study(service, version, mode, path + ["parametric_study"])
                self.add_histogram_to_report = self.__class__.add_histogram_to_report(service, version, mode, path + ["add_histogram_to_report"])
                self.delete_simulation_report = self.__class__.delete_simulation_report(service, version, mode, path + ["delete_simulation_report"])
                self.duplicate_simulation_report = self.__class__.duplicate_simulation_report(service, version, mode, path + ["duplicate_simulation_report"])
                self.export_simulation_report_as_html = self.__class__.export_simulation_report_as_html(service, version, mode, path + ["export_simulation_report_as_html"])
                self.export_simulation_report_as_pdf = self.__class__.export_simulation_report_as_pdf(service, version, mode, path + ["export_simulation_report_as_pdf"])
                self.export_simulation_report_as_pptx = self.__class__.export_simulation_report_as_pptx(service, version, mode, path + ["export_simulation_report_as_pptx"])
                self.generate_simulation_report = self.__class__.generate_simulation_report(service, version, mode, path + ["generate_simulation_report"])
                self.list_simulation_reports = self.__class__.list_simulation_reports(service, version, mode, path + ["list_simulation_reports"])
                self.read_simulation_report_template_file = self.__class__.read_simulation_report_template_file(service, version, mode, path + ["read_simulation_report_template_file"])
                self.rename_simulation_report = self.__class__.rename_simulation_report(service, version, mode, path + ["rename_simulation_report"])
                self.reset_report_to_defaults = self.__class__.reset_report_to_defaults(service, version, mode, path + ["reset_report_to_defaults"])
                self.view_simulation_report = self.__class__.view_simulation_report(service, version, mode, path + ["view_simulation_report"])
                self.write_report_names_to_file = self.__class__.write_report_names_to_file(service, version, mode, path + ["write_report_names_to_file"])
                self.write_simulation_report_template_file = self.__class__.write_simulation_report_template_file(service, version, mode, path + ["write_simulation_report_template_file"])
                super().__init__(service, version, mode, path)
            class add_histogram_to_report(TUIMethod):
                """
                .
                """
            class delete_simulation_report(TUIMethod):
                """
                .
                """
            class duplicate_simulation_report(TUIMethod):
                """
                .
                """
            class export_simulation_report_as_html(TUIMethod):
                """
                .
                """
            class export_simulation_report_as_pdf(TUIMethod):
                """
                .
                """
            class export_simulation_report_as_pptx(TUIMethod):
                """
                .
                """
            class generate_simulation_report(TUIMethod):
                """
                .
                """
            class list_simulation_reports(TUIMethod):
                """
                .
                """
            class read_simulation_report_template_file(TUIMethod):
                """
                .
                """
            class rename_simulation_report(TUIMethod):
                """
                .
                """
            class reset_report_to_defaults(TUIMethod):
                """
                .
                """
            class view_simulation_report(TUIMethod):
                """
                .
                """
            class write_report_names_to_file(TUIMethod):
                """
                .
                """
            class write_simulation_report_template_file(TUIMethod):
                """
                .
                """

            class parametric_study(TUIMenu):
                """
                Enter the parametric study menu.
                """
                def __init__(self, service, version, mode, path):
                    self.generate_design_point_report = self.__class__.generate_design_point_report(service, version, mode, path + ["generate_design_point_report"])
                    self.generate_parametric_report = self.__class__.generate_parametric_report(service, version, mode, path + ["generate_parametric_report"])
                    super().__init__(service, version, mode, path)
                class generate_design_point_report(TUIMethod):
                    """
                    Generate a simulation report for an updated design point.
                    """
                class generate_parametric_report(TUIMethod):
                    """
                    Generate a parametric report for your study.
                    """

        class surface_integrals(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.area = self.__class__.area(service, version, mode, path + ["area"])
                self.area_weighted_avg = self.__class__.area_weighted_avg(service, version, mode, path + ["area_weighted_avg"])
                self.facet_avg = self.__class__.facet_avg(service, version, mode, path + ["facet_avg"])
                self.facet_max = self.__class__.facet_max(service, version, mode, path + ["facet_max"])
                self.facet_min = self.__class__.facet_min(service, version, mode, path + ["facet_min"])
                self.flow_rate = self.__class__.flow_rate(service, version, mode, path + ["flow_rate"])
                self.integral = self.__class__.integral(service, version, mode, path + ["integral"])
                self.mass_flow_rate = self.__class__.mass_flow_rate(service, version, mode, path + ["mass_flow_rate"])
                self.mass_weighted_avg = self.__class__.mass_weighted_avg(service, version, mode, path + ["mass_weighted_avg"])
                self.standard_deviation = self.__class__.standard_deviation(service, version, mode, path + ["standard_deviation"])
                self.sum = self.__class__.sum(service, version, mode, path + ["sum"])
                self.uniformity_index_area_weighted = self.__class__.uniformity_index_area_weighted(service, version, mode, path + ["uniformity_index_area_weighted"])
                self.uniformity_index_mass_weighted = self.__class__.uniformity_index_mass_weighted(service, version, mode, path + ["uniformity_index_mass_weighted"])
                self.vector_based_flux = self.__class__.vector_based_flux(service, version, mode, path + ["vector_based_flux"])
                self.vector_flux = self.__class__.vector_flux(service, version, mode, path + ["vector_flux"])
                self.vector_weighted_average = self.__class__.vector_weighted_average(service, version, mode, path + ["vector_weighted_average"])
                self.vertex_avg = self.__class__.vertex_avg(service, version, mode, path + ["vertex_avg"])
                self.vertex_max = self.__class__.vertex_max(service, version, mode, path + ["vertex_max"])
                self.vertex_min = self.__class__.vertex_min(service, version, mode, path + ["vertex_min"])
                self.volume_flow_rate = self.__class__.volume_flow_rate(service, version, mode, path + ["volume_flow_rate"])
                super().__init__(service, version, mode, path)
            class area(TUIMethod):
                """
                .
                """
            class area_weighted_avg(TUIMethod):
                """
                .
                """
            class facet_avg(TUIMethod):
                """
                .
                """
            class facet_max(TUIMethod):
                """
                .
                """
            class facet_min(TUIMethod):
                """
                .
                """
            class flow_rate(TUIMethod):
                """
                .
                """
            class integral(TUIMethod):
                """
                .
                """
            class mass_flow_rate(TUIMethod):
                """
                .
                """
            class mass_weighted_avg(TUIMethod):
                """
                .
                """
            class standard_deviation(TUIMethod):
                """
                .
                """
            class sum(TUIMethod):
                """
                .
                """
            class uniformity_index_area_weighted(TUIMethod):
                """
                .
                """
            class uniformity_index_mass_weighted(TUIMethod):
                """
                .
                """
            class vector_based_flux(TUIMethod):
                """
                .
                """
            class vector_flux(TUIMethod):
                """
                .
                """
            class vector_weighted_average(TUIMethod):
                """
                .
                """
            class vertex_avg(TUIMethod):
                """
                .
                """
            class vertex_max(TUIMethod):
                """
                .
                """
            class vertex_min(TUIMethod):
                """
                .
                """
            class volume_flow_rate(TUIMethod):
                """
                .
                """

        class system(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.gpgpu_stats = self.__class__.gpgpu_stats(service, version, mode, path + ["gpgpu_stats"])
                self.proc_stats = self.__class__.proc_stats(service, version, mode, path + ["proc_stats"])
                self.sys_stats = self.__class__.sys_stats(service, version, mode, path + ["sys_stats"])
                self.time_stats = self.__class__.time_stats(service, version, mode, path + ["time_stats"])
                super().__init__(service, version, mode, path)
            class gpgpu_stats(TUIMethod):
                """
                .
                """
            class proc_stats(TUIMethod):
                """
                .
                """
            class sys_stats(TUIMethod):
                """
                .
                """
            class time_stats(TUIMethod):
                """
                .
                """

        class volume_integrals(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.mass = self.__class__.mass(service, version, mode, path + ["mass"])
                self.mass_avg = self.__class__.mass_avg(service, version, mode, path + ["mass_avg"])
                self.mass_integral = self.__class__.mass_integral(service, version, mode, path + ["mass_integral"])
                self.maximum = self.__class__.maximum(service, version, mode, path + ["maximum"])
                self.minimum = self.__class__.minimum(service, version, mode, path + ["minimum"])
                self.sum = self.__class__.sum(service, version, mode, path + ["sum"])
                self.twopisum = self.__class__.twopisum(service, version, mode, path + ["twopisum"])
                self.volume = self.__class__.volume(service, version, mode, path + ["volume"])
                self.volume_avg = self.__class__.volume_avg(service, version, mode, path + ["volume_avg"])
                self.volume_integral = self.__class__.volume_integral(service, version, mode, path + ["volume_integral"])
                super().__init__(service, version, mode, path)
            class mass(TUIMethod):
                """
                .
                """
            class mass_avg(TUIMethod):
                """
                .
                """
            class mass_integral(TUIMethod):
                """
                .
                """
            class maximum(TUIMethod):
                """
                .
                """
            class minimum(TUIMethod):
                """
                .
                """
            class sum(TUIMethod):
                """
                .
                """
            class twopisum(TUIMethod):
                """
                .
                """
            class volume(TUIMethod):
                """
                .
                """
            class volume_avg(TUIMethod):
                """
                .
                """
            class volume_integral(TUIMethod):
                """
                .
                """

    class results(TUIMenu):
        """
        .
        """
        def __init__(self, service, version, mode, path):
            self.animations = self.__class__.animations(service, version, mode, path + ["animations"])
            self.custom_field_functions = self.__class__.custom_field_functions(service, version, mode, path + ["custom_field_functions"])
            self.custom_vectors = self.__class__.custom_vectors(service, version, mode, path + ["custom_vectors"])
            self.graphics = self.__class__.graphics(service, version, mode, path + ["graphics"])
            self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
            self.report = self.__class__.report(service, version, mode, path + ["report"])
            self.scene = self.__class__.scene(service, version, mode, path + ["scene"])
            self.surfaces = self.__class__.surfaces(service, version, mode, path + ["surfaces"])
            super().__init__(service, version, mode, path)

        class animations(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.playback = self.__class__.playback(service, version, mode, path + ["playback"])
                self.scene_animation = self.__class__.scene_animation(service, version, mode, path + ["scene_animation"])
                super().__init__(service, version, mode, path)

            class playback(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.set_custom_frames = self.__class__.set_custom_frames(service, version, mode, path + ["set_custom_frames"])
                    self.video = self.__class__.video(service, version, mode, path + ["video"])
                    self.current_animation = self.__class__.current_animation(service, version, mode, path + ["current_animation"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.play = self.__class__.play(service, version, mode, path + ["play"])
                    self.read_animation_file = self.__class__.read_animation_file(service, version, mode, path + ["read_animation_file"])
                    self.stored_view = self.__class__.stored_view(service, version, mode, path + ["stored_view"])
                    self.write_animation = self.__class__.write_animation(service, version, mode, path + ["write_animation"])
                    super().__init__(service, version, mode, path)
                class current_animation(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class play(TUIMethod):
                    """
                    .
                    """
                class read_animation_file(TUIMethod):
                    """
                    .
                    """
                class stored_view(TUIMethod):
                    """
                    .
                    """
                class write_animation(TUIMethod):
                    """
                    .
                    """

                class set_custom_frames(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.end_frame = self.__class__.end_frame(service, version, mode, path + ["end_frame"])
                        self.increment = self.__class__.increment(service, version, mode, path + ["increment"])
                        self.start_frame = self.__class__.start_frame(service, version, mode, path + ["start_frame"])
                        super().__init__(service, version, mode, path)
                    class end_frame(TUIMethod):
                        """
                        .
                        """
                    class increment(TUIMethod):
                        """
                        .
                        """
                    class start_frame(TUIMethod):
                        """
                        .
                        """

                class video(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.advance_quality = self.__class__.advance_quality(service, version, mode, path + ["advance_quality"])
                        self.format = self.__class__.format(service, version, mode, path + ["format"])
                        self.fps = self.__class__.fps(service, version, mode, path + ["fps"])
                        self.height = self.__class__.height(service, version, mode, path + ["height"])
                        self.name = self.__class__.name(service, version, mode, path + ["name"])
                        self.quality = self.__class__.quality(service, version, mode, path + ["quality"])
                        self.scale = self.__class__.scale(service, version, mode, path + ["scale"])
                        self.set_standard_resolution = self.__class__.set_standard_resolution(service, version, mode, path + ["set_standard_resolution"])
                        self.use_original_resolution = self.__class__.use_original_resolution(service, version, mode, path + ["use_original_resolution"])
                        self.width = self.__class__.width(service, version, mode, path + ["width"])
                        super().__init__(service, version, mode, path)
                    class format(TUIMethod):
                        """
                        .
                        """
                    class fps(TUIMethod):
                        """
                        .
                        """
                    class height(TUIMethod):
                        """
                        .
                        """
                    class name(TUIMethod):
                        """
                        .
                        """
                    class quality(TUIMethod):
                        """
                        .
                        """
                    class scale(TUIMethod):
                        """
                        .
                        """
                    class set_standard_resolution(TUIMethod):
                        """
                        .
                        """
                    class use_original_resolution(TUIMethod):
                        """
                        .
                        """
                    class width(TUIMethod):
                        """
                        .
                        """

                    class advance_quality(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.bitrate = self.__class__.bitrate(service, version, mode, path + ["bitrate"])
                            self.bitrate_scale = self.__class__.bitrate_scale(service, version, mode, path + ["bitrate_scale"])
                            self.compression_method = self.__class__.compression_method(service, version, mode, path + ["compression_method"])
                            self.enable_h264 = self.__class__.enable_h264(service, version, mode, path + ["enable_h264"])
                            self.keyframe = self.__class__.keyframe(service, version, mode, path + ["keyframe"])
                            super().__init__(service, version, mode, path)
                        class bitrate(TUIMethod):
                            """
                            .
                            """
                        class bitrate_scale(TUIMethod):
                            """
                            .
                            """
                        class compression_method(TUIMethod):
                            """
                            .
                            """
                        class enable_h264(TUIMethod):
                            """
                            .
                            """
                        class keyframe(TUIMethod):
                            """
                            .
                            """

            class scene_animation(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.set_custom_frames = self.__class__.set_custom_frames(service, version, mode, path + ["set_custom_frames"])
                    self.add_keyframe = self.__class__.add_keyframe(service, version, mode, path + ["add_keyframe"])
                    self.delete_all_keyframes = self.__class__.delete_all_keyframes(service, version, mode, path + ["delete_all_keyframes"])
                    self.delete_keyframe = self.__class__.delete_keyframe(service, version, mode, path + ["delete_keyframe"])
                    self.play = self.__class__.play(service, version, mode, path + ["play"])
                    self.read_animation = self.__class__.read_animation(service, version, mode, path + ["read_animation"])
                    self.write_animation = self.__class__.write_animation(service, version, mode, path + ["write_animation"])
                    super().__init__(service, version, mode, path)
                class add_keyframe(TUIMethod):
                    """
                    .
                    """
                class delete_all_keyframes(TUIMethod):
                    """
                    .
                    """
                class delete_keyframe(TUIMethod):
                    """
                    .
                    """
                class play(TUIMethod):
                    """
                    .
                    """
                class read_animation(TUIMethod):
                    """
                    .
                    """
                class write_animation(TUIMethod):
                    """
                    .
                    """

                class set_custom_frames(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.end_keyframe = self.__class__.end_keyframe(service, version, mode, path + ["end_keyframe"])
                        self.increment = self.__class__.increment(service, version, mode, path + ["increment"])
                        self.start_keyframe = self.__class__.start_keyframe(service, version, mode, path + ["start_keyframe"])
                        super().__init__(service, version, mode, path)
                    class end_keyframe(TUIMethod):
                        """
                        .
                        """
                    class increment(TUIMethod):
                        """
                        .
                        """
                    class start_keyframe(TUIMethod):
                        """
                        .
                        """

        class custom_field_functions(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.load = self.__class__.load(service, version, mode, path + ["load"])
                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                self.save = self.__class__.save(service, version, mode, path + ["save"])
                super().__init__(service, version, mode, path)
            class create(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class edit(TUIMethod):
                """
                Edit custom-field-functions object.
                """
            class list(TUIMethod):
                """
                .
                """
            class list_properties(TUIMethod):
                """
                .
                """
            class load(TUIMethod):
                """
                .
                """
            class make_a_copy(TUIMethod):
                """
                .
                """
            class rename(TUIMethod):
                """
                .
                """
            class save(TUIMethod):
                """
                .
                """

        class custom_vectors(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                super().__init__(service, version, mode, path)
            class create(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class edit(TUIMethod):
                """
                Edit custom-vectors object.
                """
            class list(TUIMethod):
                """
                .
                """
            class list_properties(TUIMethod):
                """
                .
                """
            class make_a_copy(TUIMethod):
                """
                .
                """
            class rename(TUIMethod):
                """
                .
                """

        class graphics(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.colors = self.__class__.colors(service, version, mode, path + ["colors"])
                self.contour = self.__class__.contour(service, version, mode, path + ["contour"])
                self.contours = self.__class__.contours(service, version, mode, path + ["contours"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.lic = self.__class__.lic(service, version, mode, path + ["lic"])
                self.lighting = self.__class__.lighting(service, version, mode, path + ["lighting"])
                self.material = self.__class__.material(service, version, mode, path + ["material"])
                self.mesh = self.__class__.mesh(service, version, mode, path + ["mesh"])
                self.olic = self.__class__.olic(service, version, mode, path + ["olic"])
                self.particle_track = self.__class__.particle_track(service, version, mode, path + ["particle_track"])
                self.particle_tracks = self.__class__.particle_tracks(service, version, mode, path + ["particle_tracks"])
                self.pathline = self.__class__.pathline(service, version, mode, path + ["pathline"])
                self.periodic_instances = self.__class__.periodic_instances(service, version, mode, path + ["periodic_instances"])
                self.picture = self.__class__.picture(service, version, mode, path + ["picture"])
                self.pulse = self.__class__.pulse(service, version, mode, path + ["pulse"])
                self.raytracing_options = self.__class__.raytracing_options(service, version, mode, path + ["raytracing_options"])
                self.vector = self.__class__.vector(service, version, mode, path + ["vector"])
                self.views = self.__class__.views(service, version, mode, path + ["views"])
                self.volumes = self.__class__.volumes(service, version, mode, path + ["volumes"])
                self.windows = self.__class__.windows(service, version, mode, path + ["windows"])
                super().__init__(service, version, mode, path)

            class colors(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.by_surface = self.__class__.by_surface(service, version, mode, path + ["by_surface"])
                    self.by_type = self.__class__.by_type(service, version, mode, path + ["by_type"])
                    self.automatic_skip = self.__class__.automatic_skip(service, version, mode, path + ["automatic_skip"])
                    self.axis_faces = self.__class__.axis_faces(service, version, mode, path + ["axis_faces"])
                    self.background = self.__class__.background(service, version, mode, path + ["background"])
                    self.color_by_type = self.__class__.color_by_type(service, version, mode, path + ["color_by_type"])
                    self.far_field_faces = self.__class__.far_field_faces(service, version, mode, path + ["far_field_faces"])
                    self.foreground = self.__class__.foreground(service, version, mode, path + ["foreground"])
                    self.free_surface_faces = self.__class__.free_surface_faces(service, version, mode, path + ["free_surface_faces"])
                    self.inlet_faces = self.__class__.inlet_faces(service, version, mode, path + ["inlet_faces"])
                    self.interface_faces = self.__class__.interface_faces(service, version, mode, path + ["interface_faces"])
                    self.interior_faces = self.__class__.interior_faces(service, version, mode, path + ["interior_faces"])
                    self.internal_faces = self.__class__.internal_faces(service, version, mode, path + ["internal_faces"])
                    self.list_colors = self.__class__.list_colors(service, version, mode, path + ["list_colors"])
                    self.outlet_faces = self.__class__.outlet_faces(service, version, mode, path + ["outlet_faces"])
                    self.overset_faces = self.__class__.overset_faces(service, version, mode, path + ["overset_faces"])
                    self.periodic_faces = self.__class__.periodic_faces(service, version, mode, path + ["periodic_faces"])
                    self.rans_les_interface_faces = self.__class__.rans_les_interface_faces(service, version, mode, path + ["rans_les_interface_faces"])
                    self.reset_colors = self.__class__.reset_colors(service, version, mode, path + ["reset_colors"])
                    self.skip_label = self.__class__.skip_label(service, version, mode, path + ["skip_label"])
                    self.surface = self.__class__.surface(service, version, mode, path + ["surface"])
                    self.symmetry_faces = self.__class__.symmetry_faces(service, version, mode, path + ["symmetry_faces"])
                    self.traction_faces = self.__class__.traction_faces(service, version, mode, path + ["traction_faces"])
                    self.wall_faces = self.__class__.wall_faces(service, version, mode, path + ["wall_faces"])
                    super().__init__(service, version, mode, path)
                class automatic_skip(TUIMethod):
                    """
                    .
                    """
                class axis_faces(TUIMethod):
                    """
                    .
                    """
                class background(TUIMethod):
                    """
                    .
                    """
                class color_by_type(TUIMethod):
                    """
                    .
                    """
                class far_field_faces(TUIMethod):
                    """
                    .
                    """
                class foreground(TUIMethod):
                    """
                    .
                    """
                class free_surface_faces(TUIMethod):
                    """
                    .
                    """
                class inlet_faces(TUIMethod):
                    """
                    .
                    """
                class interface_faces(TUIMethod):
                    """
                    .
                    """
                class interior_faces(TUIMethod):
                    """
                    .
                    """
                class internal_faces(TUIMethod):
                    """
                    .
                    """
                class list_colors(TUIMethod):
                    """
                    .
                    """
                class outlet_faces(TUIMethod):
                    """
                    .
                    """
                class overset_faces(TUIMethod):
                    """
                    .
                    """
                class periodic_faces(TUIMethod):
                    """
                    .
                    """
                class rans_les_interface_faces(TUIMethod):
                    """
                    .
                    """
                class reset_colors(TUIMethod):
                    """
                    .
                    """
                class skip_label(TUIMethod):
                    """
                    .
                    """
                class surface(TUIMethod):
                    """
                    .
                    """
                class symmetry_faces(TUIMethod):
                    """
                    .
                    """
                class traction_faces(TUIMethod):
                    """
                    .
                    """
                class wall_faces(TUIMethod):
                    """
                    .
                    """

                class by_surface(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.list_surfaces_by_color = self.__class__.list_surfaces_by_color(service, version, mode, path + ["list_surfaces_by_color"])
                        self.list_surfaces_by_material = self.__class__.list_surfaces_by_material(service, version, mode, path + ["list_surfaces_by_material"])
                        self.reset = self.__class__.reset(service, version, mode, path + ["reset"])
                        self.surfaces = self.__class__.surfaces(service, version, mode, path + ["surfaces"])
                        self.use_inherent_material_color = self.__class__.use_inherent_material_color(service, version, mode, path + ["use_inherent_material_color"])
                        super().__init__(service, version, mode, path)
                    class list_surfaces_by_color(TUIMethod):
                        """
                        .
                        """
                    class list_surfaces_by_material(TUIMethod):
                        """
                        .
                        """
                    class reset(TUIMethod):
                        """
                        .
                        """
                    class surfaces(TUIMethod):
                        """
                        .
                        """
                    class use_inherent_material_color(TUIMethod):
                        """
                        .
                        """

                class by_type(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.type_name = self.__class__.type_name(service, version, mode, path + ["type_name"])
                        self.only_list_case_boundaries = self.__class__.only_list_case_boundaries(service, version, mode, path + ["only_list_case_boundaries"])
                        self.reset = self.__class__.reset(service, version, mode, path + ["reset"])
                        self.use_inherent_material_color = self.__class__.use_inherent_material_color(service, version, mode, path + ["use_inherent_material_color"])
                        super().__init__(service, version, mode, path)
                    class only_list_case_boundaries(TUIMethod):
                        """
                        .
                        """
                    class reset(TUIMethod):
                        """
                        .
                        """
                    class use_inherent_material_color(TUIMethod):
                        """
                        .
                        """

                    class type_name(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.create = self.__class__.create(service, version, mode, path + ["create"])
                            self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                            self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                            super().__init__(service, version, mode, path)
                        class create(TUIMethod):
                            """
                            .
                            """
                        class delete(TUIMethod):
                            """
                            .
                            """
                        class edit(TUIMethod):
                            """
                            Edit type-name object.
                            """
                        class list(TUIMethod):
                            """
                            .
                            """
                        class list_properties(TUIMethod):
                            """
                            .
                            """
                        class make_a_copy(TUIMethod):
                            """
                            .
                            """
                        class rename(TUIMethod):
                            """
                            .
                            """

            class contour(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit contour object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class contours(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.coloring = self.__class__.coloring(service, version, mode, path + ["coloring"])
                    self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
                    self.clip_to_range = self.__class__.clip_to_range(service, version, mode, path + ["clip_to_range"])
                    self.filled_contours = self.__class__.filled_contours(service, version, mode, path + ["filled_contours"])
                    self.global_range = self.__class__.global_range(service, version, mode, path + ["global_range"])
                    self.line_contours = self.__class__.line_contours(service, version, mode, path + ["line_contours"])
                    self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                    self.n_contour = self.__class__.n_contour(service, version, mode, path + ["n_contour"])
                    self.node_values = self.__class__.node_values(service, version, mode, path + ["node_values"])
                    self.render_mesh = self.__class__.render_mesh(service, version, mode, path + ["render_mesh"])
                    self.surfaces = self.__class__.surfaces(service, version, mode, path + ["surfaces"])
                    super().__init__(service, version, mode, path)
                class auto_scale(TUIMethod):
                    """
                    .
                    """
                class clip_to_range(TUIMethod):
                    """
                    .
                    """
                class filled_contours(TUIMethod):
                    """
                    .
                    """
                class global_range(TUIMethod):
                    """
                    .
                    """
                class line_contours(TUIMethod):
                    """
                    .
                    """
                class log_scale(TUIMethod):
                    """
                    .
                    """
                class n_contour(TUIMethod):
                    """
                    .
                    """
                class node_values(TUIMethod):
                    """
                    .
                    """
                class render_mesh(TUIMethod):
                    """
                    .
                    """
                class surfaces(TUIMethod):
                    """
                    .
                    """

                class coloring(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.banded_coloring = self.__class__.banded_coloring(service, version, mode, path + ["banded_coloring"])
                        self.number_of_bands = self.__class__.number_of_bands(service, version, mode, path + ["number_of_bands"])
                        super().__init__(service, version, mode, path)
                    class banded_coloring(TUIMethod):
                        """
                        .
                        """
                    class number_of_bands(TUIMethod):
                        """
                        .
                        """

            class display(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.surface_mesh = self.__class__.surface_mesh(service, version, mode, path + ["surface_mesh"])
                    self.zone_mesh = self.__class__.zone_mesh(service, version, mode, path + ["zone_mesh"])
                    super().__init__(service, version, mode, path)
                class surface_mesh(TUIMethod):
                    """
                    .
                    """
                class zone_mesh(TUIMethod):
                    """
                    .
                    """

            class lic(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit lic object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class lighting(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.lights = self.__class__.lights(service, version, mode, path + ["lights"])
                    self.ambient_color = self.__class__.ambient_color(service, version, mode, path + ["ambient_color"])
                    self.headlight_setting = self.__class__.headlight_setting(service, version, mode, path + ["headlight_setting"])
                    self.lighting_interpolation = self.__class__.lighting_interpolation(service, version, mode, path + ["lighting_interpolation"])
                    self.lights_on = self.__class__.lights_on(service, version, mode, path + ["lights_on"])
                    super().__init__(service, version, mode, path)
                class ambient_color(TUIMethod):
                    """
                    .
                    """
                class headlight_setting(TUIMethod):
                    """
                    .
                    """
                class lighting_interpolation(TUIMethod):
                    """
                    .
                    """
                class lights_on(TUIMethod):
                    """
                    .
                    """

                class lights(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit lights object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

            class material(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit material object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class mesh(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit mesh object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class olic(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit olic object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class particle_track(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit particle-track object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class particle_tracks(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.arrow_scale = self.__class__.arrow_scale(service, version, mode, path + ["arrow_scale"])
                    self.arrow_space = self.__class__.arrow_space(service, version, mode, path + ["arrow_space"])
                    self.coarsen_factor = self.__class__.coarsen_factor(service, version, mode, path + ["coarsen_factor"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.history_filename = self.__class__.history_filename(service, version, mode, path + ["history_filename"])
                    self.line_width = self.__class__.line_width(service, version, mode, path + ["line_width"])
                    self.report_default_variables = self.__class__.report_default_variables(service, version, mode, path + ["report_default_variables"])
                    self.track_single_particle_stream = self.__class__.track_single_particle_stream(service, version, mode, path + ["track_single_particle_stream"])
                    super().__init__(service, version, mode, path)
                class arrow_scale(TUIMethod):
                    """
                    .
                    """
                class arrow_space(TUIMethod):
                    """
                    .
                    """
                class coarsen_factor(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class history_filename(TUIMethod):
                    """
                    .
                    """
                class line_width(TUIMethod):
                    """
                    .
                    """
                class report_default_variables(TUIMethod):
                    """
                    .
                    """
                class track_single_particle_stream(TUIMethod):
                    """
                    .
                    """

            class pathline(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit pathline object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class periodic_instances(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.clear_repeats = self.__class__.clear_repeats(service, version, mode, path + ["clear_repeats"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.detect_surfaces = self.__class__.detect_surfaces(service, version, mode, path + ["detect_surfaces"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class clear_repeats(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class detect_surfaces(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit periodic-instances object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class picture(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.driver_options = self.__class__.driver_options(service, version, mode, path + ["driver_options"])
                    self.color_mode = self.__class__.color_mode(service, version, mode, path + ["color_mode"])
                    self.dpi = self.__class__.dpi(service, version, mode, path + ["dpi"])
                    self.invert_background = self.__class__.invert_background(service, version, mode, path + ["invert_background"])
                    self.invert_normals_for_avz = self.__class__.invert_normals_for_avz(service, version, mode, path + ["invert_normals_for_avz"])
                    self.jpeg_hardcopy_quality = self.__class__.jpeg_hardcopy_quality(service, version, mode, path + ["jpeg_hardcopy_quality"])
                    self.landscape = self.__class__.landscape(service, version, mode, path + ["landscape"])
                    self.list_color_mode = self.__class__.list_color_mode(service, version, mode, path + ["list_color_mode"])
                    self.preview = self.__class__.preview(service, version, mode, path + ["preview"])
                    self.raytracer_image = self.__class__.raytracer_image(service, version, mode, path + ["raytracer_image"])
                    self.save_picture = self.__class__.save_picture(service, version, mode, path + ["save_picture"])
                    self.standard_resolution = self.__class__.standard_resolution(service, version, mode, path + ["standard_resolution"])
                    self.use_window_resolution = self.__class__.use_window_resolution(service, version, mode, path + ["use_window_resolution"])
                    self.x_resolution = self.__class__.x_resolution(service, version, mode, path + ["x_resolution"])
                    self.y_resolution = self.__class__.y_resolution(service, version, mode, path + ["y_resolution"])
                    super().__init__(service, version, mode, path)
                class color_mode(TUIMethod):
                    """
                    .
                    """
                class dpi(TUIMethod):
                    """
                    .
                    """
                class invert_background(TUIMethod):
                    """
                    .
                    """
                class invert_normals_for_avz(TUIMethod):
                    """
                    .
                    """
                class jpeg_hardcopy_quality(TUIMethod):
                    """
                    .
                    """
                class landscape(TUIMethod):
                    """
                    .
                    """
                class list_color_mode(TUIMethod):
                    """
                    .
                    """
                class preview(TUIMethod):
                    """
                    .
                    """
                class raytracer_image(TUIMethod):
                    """
                    .
                    """
                class save_picture(TUIMethod):
                    """
                    .
                    """
                class standard_resolution(TUIMethod):
                    """
                    .
                    """
                class use_window_resolution(TUIMethod):
                    """
                    .
                    """
                class x_resolution(TUIMethod):
                    """
                    .
                    """
                class y_resolution(TUIMethod):
                    """
                    .
                    """

                class driver_options(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.current_driver = self.__class__.current_driver(service, version, mode, path + ["current_driver"])
                        self.hardcopy_format = self.__class__.hardcopy_format(service, version, mode, path + ["hardcopy_format"])
                        self.hardcopy_options = self.__class__.hardcopy_options(service, version, mode, path + ["hardcopy_options"])
                        self.post_format = self.__class__.post_format(service, version, mode, path + ["post_format"])
                        self.window_dump_cmd = self.__class__.window_dump_cmd(service, version, mode, path + ["window_dump_cmd"])
                        super().__init__(service, version, mode, path)
                    class current_driver(TUIMethod):
                        """
                        .
                        """
                    class hardcopy_format(TUIMethod):
                        """
                        .
                        """
                    class hardcopy_options(TUIMethod):
                        """
                        .
                        """
                    class post_format(TUIMethod):
                        """
                        .
                        """
                    class window_dump_cmd(TUIMethod):
                        """
                        .
                        """

            class pulse(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.pulse_mode = self.__class__.pulse_mode(service, version, mode, path + ["pulse_mode"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    super().__init__(service, version, mode, path)
                class pulse_mode(TUIMethod):
                    """
                    .
                    """
                class write(TUIMethod):
                    """
                    .
                    """

            class raytracing_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.background = self.__class__.background(service, version, mode, path + ["background"])
                    self.rendering = self.__class__.rendering(service, version, mode, path + ["rendering"])
                    self.display_live_preview = self.__class__.display_live_preview(service, version, mode, path + ["display_live_preview"])
                    super().__init__(service, version, mode, path)
                class display_live_preview(TUIMethod):
                    """
                    .
                    """

                class background(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.activate_env_ground = self.__class__.activate_env_ground(service, version, mode, path + ["activate_env_ground"])
                        self.activate_env_ground_shadow = self.__class__.activate_env_ground_shadow(service, version, mode, path + ["activate_env_ground_shadow"])
                        self.backplate_color = self.__class__.backplate_color(service, version, mode, path + ["backplate_color"])
                        self.backplate_image = self.__class__.backplate_image(service, version, mode, path + ["backplate_image"])
                        self.env_color = self.__class__.env_color(service, version, mode, path + ["env_color"])
                        self.env_intensity = self.__class__.env_intensity(service, version, mode, path + ["env_intensity"])
                        self.env_light_dirvec = self.__class__.env_light_dirvec(service, version, mode, path + ["env_light_dirvec"])
                        self.env_light_ground_height = self.__class__.env_light_ground_height(service, version, mode, path + ["env_light_ground_height"])
                        self.env_light_upvec = self.__class__.env_light_upvec(service, version, mode, path + ["env_light_upvec"])
                        self.environment_image = self.__class__.environment_image(service, version, mode, path + ["environment_image"])
                        self.ground_shadow_axis = self.__class__.ground_shadow_axis(service, version, mode, path + ["ground_shadow_axis"])
                        self.hide_environment_keep_effects = self.__class__.hide_environment_keep_effects(service, version, mode, path + ["hide_environment_keep_effects"])
                        self.horizontal = self.__class__.horizontal(service, version, mode, path + ["horizontal"])
                        self.is_ground_shadow_at_fix_axis = self.__class__.is_ground_shadow_at_fix_axis(service, version, mode, path + ["is_ground_shadow_at_fix_axis"])
                        self.model_scale = self.__class__.model_scale(service, version, mode, path + ["model_scale"])
                        self.show_backplate = self.__class__.show_backplate(service, version, mode, path + ["show_backplate"])
                        self.spin = self.__class__.spin(service, version, mode, path + ["spin"])
                        self.vertical = self.__class__.vertical(service, version, mode, path + ["vertical"])
                        self.view_zoom = self.__class__.view_zoom(service, version, mode, path + ["view_zoom"])
                        super().__init__(service, version, mode, path)
                    class activate_env_ground(TUIMethod):
                        """
                        .
                        """
                    class activate_env_ground_shadow(TUIMethod):
                        """
                        .
                        """
                    class backplate_color(TUIMethod):
                        """
                        .
                        """
                    class backplate_image(TUIMethod):
                        """
                        .
                        """
                    class env_color(TUIMethod):
                        """
                        .
                        """
                    class env_intensity(TUIMethod):
                        """
                        .
                        """
                    class env_light_dirvec(TUIMethod):
                        """
                        .
                        """
                    class env_light_ground_height(TUIMethod):
                        """
                        .
                        """
                    class env_light_upvec(TUIMethod):
                        """
                        .
                        """
                    class environment_image(TUIMethod):
                        """
                        .
                        """
                    class ground_shadow_axis(TUIMethod):
                        """
                        .
                        """
                    class hide_environment_keep_effects(TUIMethod):
                        """
                        .
                        """
                    class horizontal(TUIMethod):
                        """
                        .
                        """
                    class is_ground_shadow_at_fix_axis(TUIMethod):
                        """
                        .
                        """
                    class model_scale(TUIMethod):
                        """
                        .
                        """
                    class show_backplate(TUIMethod):
                        """
                        .
                        """
                    class spin(TUIMethod):
                        """
                        .
                        """
                    class vertical(TUIMethod):
                        """
                        .
                        """
                    class view_zoom(TUIMethod):
                        """
                        .
                        """

                class rendering(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.denoiser = self.__class__.denoiser(service, version, mode, path + ["denoiser"])
                        self.max_rendering_timeout = self.__class__.max_rendering_timeout(service, version, mode, path + ["max_rendering_timeout"])
                        self.quality = self.__class__.quality(service, version, mode, path + ["quality"])
                        self.thread_count = self.__class__.thread_count(service, version, mode, path + ["thread_count"])
                        super().__init__(service, version, mode, path)
                    class denoiser(TUIMethod):
                        """
                        .
                        """
                    class max_rendering_timeout(TUIMethod):
                        """
                        .
                        """
                    class quality(TUIMethod):
                        """
                        .
                        """
                    class thread_count(TUIMethod):
                        """
                        .
                        """

            class vector(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit vector object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class views(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.camera = self.__class__.camera(service, version, mode, path + ["camera"])
                    self.display_states = self.__class__.display_states(service, version, mode, path + ["display_states"])
                    self.mirror_planes = self.__class__.mirror_planes(service, version, mode, path + ["mirror_planes"])
                    self.rendering_options = self.__class__.rendering_options(service, version, mode, path + ["rendering_options"])
                    self.apply_mirror_planes = self.__class__.apply_mirror_planes(service, version, mode, path + ["apply_mirror_planes"])
                    self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
                    self.delete_view = self.__class__.delete_view(service, version, mode, path + ["delete_view"])
                    self.last_view = self.__class__.last_view(service, version, mode, path + ["last_view"])
                    self.list_views = self.__class__.list_views(service, version, mode, path + ["list_views"])
                    self.mirror_zones = self.__class__.mirror_zones(service, version, mode, path + ["mirror_zones"])
                    self.next_view = self.__class__.next_view(service, version, mode, path + ["next_view"])
                    self.read_views = self.__class__.read_views(service, version, mode, path + ["read_views"])
                    self.reset_to_default_view = self.__class__.reset_to_default_view(service, version, mode, path + ["reset_to_default_view"])
                    self.restore_view = self.__class__.restore_view(service, version, mode, path + ["restore_view"])
                    self.save_view = self.__class__.save_view(service, version, mode, path + ["save_view"])
                    self.write_views = self.__class__.write_views(service, version, mode, path + ["write_views"])
                    super().__init__(service, version, mode, path)
                class apply_mirror_planes(TUIMethod):
                    """
                    .
                    """
                class auto_scale(TUIMethod):
                    """
                    .
                    """
                class delete_view(TUIMethod):
                    """
                    .
                    """
                class last_view(TUIMethod):
                    """
                    .
                    """
                class list_views(TUIMethod):
                    """
                    .
                    """
                class mirror_zones(TUIMethod):
                    """
                    .
                    """
                class next_view(TUIMethod):
                    """
                    .
                    """
                class read_views(TUIMethod):
                    """
                    .
                    """
                class reset_to_default_view(TUIMethod):
                    """
                    .
                    """
                class restore_view(TUIMethod):
                    """
                    .
                    """
                class save_view(TUIMethod):
                    """
                    .
                    """
                class write_views(TUIMethod):
                    """
                    .
                    """

                class camera(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.dolly = self.__class__.dolly(service, version, mode, path + ["dolly"])
                        self.field = self.__class__.field(service, version, mode, path + ["field"])
                        self.orbit = self.__class__.orbit(service, version, mode, path + ["orbit"])
                        self.pan = self.__class__.pan(service, version, mode, path + ["pan"])
                        self.position = self.__class__.position(service, version, mode, path + ["position"])
                        self.projection = self.__class__.projection(service, version, mode, path + ["projection"])
                        self.roll = self.__class__.roll(service, version, mode, path + ["roll"])
                        self.target = self.__class__.target(service, version, mode, path + ["target"])
                        self.up_vector = self.__class__.up_vector(service, version, mode, path + ["up_vector"])
                        self.zoom = self.__class__.zoom(service, version, mode, path + ["zoom"])
                        super().__init__(service, version, mode, path)
                    class dolly(TUIMethod):
                        """
                        .
                        """
                    class field(TUIMethod):
                        """
                        .
                        """
                    class orbit(TUIMethod):
                        """
                        .
                        """
                    class pan(TUIMethod):
                        """
                        .
                        """
                    class position(TUIMethod):
                        """
                        .
                        """
                    class projection(TUIMethod):
                        """
                        .
                        """
                    class roll(TUIMethod):
                        """
                        .
                        """
                    class target(TUIMethod):
                        """
                        .
                        """
                    class up_vector(TUIMethod):
                        """
                        .
                        """
                    class zoom(TUIMethod):
                        """
                        .
                        """

                class display_states(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.read = self.__class__.read(service, version, mode, path + ["read"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        self.restore_state = self.__class__.restore_state(service, version, mode, path + ["restore_state"])
                        self.use_active = self.__class__.use_active(service, version, mode, path + ["use_active"])
                        self.write = self.__class__.write(service, version, mode, path + ["write"])
                        super().__init__(service, version, mode, path)
                    class copy(TUIMethod):
                        """
                        .
                        """
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit display-states object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class read(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """
                    class restore_state(TUIMethod):
                        """
                        .
                        """
                    class use_active(TUIMethod):
                        """
                        .
                        """
                    class write(TUIMethod):
                        """
                        .
                        """

                class mirror_planes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit mirror-planes object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

                class rendering_options(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.animation_option = self.__class__.animation_option(service, version, mode, path + ["animation_option"])
                        self.auto_spin = self.__class__.auto_spin(service, version, mode, path + ["auto_spin"])
                        self.color_map_alignment = self.__class__.color_map_alignment(service, version, mode, path + ["color_map_alignment"])
                        self.device_info = self.__class__.device_info(service, version, mode, path + ["device_info"])
                        self.double_buffering = self.__class__.double_buffering(service, version, mode, path + ["double_buffering"])
                        self.driver = self.__class__.driver(service, version, mode, path + ["driver"])
                        self.face_displacement = self.__class__.face_displacement(service, version, mode, path + ["face_displacement"])
                        self.front_faces_transparent = self.__class__.front_faces_transparent(service, version, mode, path + ["front_faces_transparent"])
                        self.hidden_surface_method = self.__class__.hidden_surface_method(service, version, mode, path + ["hidden_surface_method"])
                        self.hidden_surfaces = self.__class__.hidden_surfaces(service, version, mode, path + ["hidden_surfaces"])
                        self.set_rendering_options = self.__class__.set_rendering_options(service, version, mode, path + ["set_rendering_options"])
                        self.show_colormap = self.__class__.show_colormap(service, version, mode, path + ["show_colormap"])
                        super().__init__(service, version, mode, path)
                    class animation_option(TUIMethod):
                        """
                        .
                        """
                    class auto_spin(TUIMethod):
                        """
                        .
                        """
                    class color_map_alignment(TUIMethod):
                        """
                        .
                        """
                    class device_info(TUIMethod):
                        """
                        .
                        """
                    class double_buffering(TUIMethod):
                        """
                        .
                        """
                    class driver(TUIMethod):
                        """
                        .
                        """
                    class face_displacement(TUIMethod):
                        """
                        .
                        """
                    class front_faces_transparent(TUIMethod):
                        """
                        .
                        """
                    class hidden_surface_method(TUIMethod):
                        """
                        .
                        """
                    class hidden_surfaces(TUIMethod):
                        """
                        .
                        """
                    class set_rendering_options(TUIMethod):
                        """
                        .
                        """
                    class show_colormap(TUIMethod):
                        """
                        .
                        """

            class volumes(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit volumes object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class windows(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.main = self.__class__.main(service, version, mode, path + ["main"])
                    self.scale = self.__class__.scale(service, version, mode, path + ["scale"])
                    self.text = self.__class__.text(service, version, mode, path + ["text"])
                    self.video = self.__class__.video(service, version, mode, path + ["video"])
                    self.xy = self.__class__.xy(service, version, mode, path + ["xy"])
                    self.aspect_ratio = self.__class__.aspect_ratio(service, version, mode, path + ["aspect_ratio"])
                    self.close_window = self.__class__.close_window(service, version, mode, path + ["close_window"])
                    self.close_window_by_name = self.__class__.close_window_by_name(service, version, mode, path + ["close_window_by_name"])
                    self.logo = self.__class__.logo(service, version, mode, path + ["logo"])
                    self.logo_color = self.__class__.logo_color(service, version, mode, path + ["logo_color"])
                    self.open_window = self.__class__.open_window(service, version, mode, path + ["open_window"])
                    self.ruler = self.__class__.ruler(service, version, mode, path + ["ruler"])
                    self.set_window = self.__class__.set_window(service, version, mode, path + ["set_window"])
                    self.set_window_by_name = self.__class__.set_window_by_name(service, version, mode, path + ["set_window_by_name"])
                    super().__init__(service, version, mode, path)
                class aspect_ratio(TUIMethod):
                    """
                    .
                    """
                class close_window(TUIMethod):
                    """
                    .
                    """
                class close_window_by_name(TUIMethod):
                    """
                    .
                    """
                class logo(TUIMethod):
                    """
                    .
                    """
                class logo_color(TUIMethod):
                    """
                    .
                    """
                class open_window(TUIMethod):
                    """
                    .
                    """
                class ruler(TUIMethod):
                    """
                    .
                    """
                class set_window(TUIMethod):
                    """
                    .
                    """
                class set_window_by_name(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.clear = self.__class__.clear(service, version, mode, path + ["clear"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class clear(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

                class main(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

                class scale(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.clear = self.__class__.clear(service, version, mode, path + ["clear"])
                        self.font_size = self.__class__.font_size(service, version, mode, path + ["font_size"])
                        self.format = self.__class__.format(service, version, mode, path + ["format"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.margin = self.__class__.margin(service, version, mode, path + ["margin"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class clear(TUIMethod):
                        """
                        .
                        """
                    class font_size(TUIMethod):
                        """
                        .
                        """
                    class format(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class margin(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

                class text(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.alignment = self.__class__.alignment(service, version, mode, path + ["alignment"])
                        self.application = self.__class__.application(service, version, mode, path + ["application"])
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.clear = self.__class__.clear(service, version, mode, path + ["clear"])
                        self.company = self.__class__.company(service, version, mode, path + ["company"])
                        self.date = self.__class__.date(service, version, mode, path + ["date"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class alignment(TUIMethod):
                        """
                        .
                        """
                    class application(TUIMethod):
                        """
                        .
                        """
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class clear(TUIMethod):
                        """
                        .
                        """
                    class company(TUIMethod):
                        """
                        .
                        """
                    class date(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

                class video(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.pixel_size = self.__class__.pixel_size(service, version, mode, path + ["pixel_size"])
                        self.background = self.__class__.background(service, version, mode, path + ["background"])
                        self.color_filter = self.__class__.color_filter(service, version, mode, path + ["color_filter"])
                        self.foreground = self.__class__.foreground(service, version, mode, path + ["foreground"])
                        self.on = self.__class__.on(service, version, mode, path + ["on"])
                        super().__init__(service, version, mode, path)
                    class background(TUIMethod):
                        """
                        .
                        """
                    class color_filter(TUIMethod):
                        """
                        .
                        """
                    class foreground(TUIMethod):
                        """
                        .
                        """
                    class on(TUIMethod):
                        """
                        .
                        """

                    class pixel_size(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.height = self.__class__.height(service, version, mode, path + ["height"])
                            self.margin = self.__class__.margin(service, version, mode, path + ["margin"])
                            self.width = self.__class__.width(service, version, mode, path + ["width"])
                            super().__init__(service, version, mode, path)
                        class height(TUIMethod):
                            """
                            .
                            """
                        class margin(TUIMethod):
                            """
                            .
                            """
                        class width(TUIMethod):
                            """
                            .
                            """

                class xy(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.border = self.__class__.border(service, version, mode, path + ["border"])
                        self.bottom = self.__class__.bottom(service, version, mode, path + ["bottom"])
                        self.left = self.__class__.left(service, version, mode, path + ["left"])
                        self.right = self.__class__.right(service, version, mode, path + ["right"])
                        self.top = self.__class__.top(service, version, mode, path + ["top"])
                        self.visible = self.__class__.visible(service, version, mode, path + ["visible"])
                        super().__init__(service, version, mode, path)
                    class border(TUIMethod):
                        """
                        .
                        """
                    class bottom(TUIMethod):
                        """
                        .
                        """
                    class left(TUIMethod):
                        """
                        .
                        """
                    class right(TUIMethod):
                        """
                        .
                        """
                    class top(TUIMethod):
                        """
                        .
                        """
                    class visible(TUIMethod):
                        """
                        .
                        """

        class plot(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.cumulative_plot = self.__class__.cumulative_plot(service, version, mode, path + ["cumulative_plot"])
                self.histogram = self.__class__.histogram(service, version, mode, path + ["histogram"])
                self.interpolated_data = self.__class__.interpolated_data(service, version, mode, path + ["interpolated_data"])
                self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                self.plot_from_file = self.__class__.plot_from_file(service, version, mode, path + ["plot_from_file"])
                self.profile_data = self.__class__.profile_data(service, version, mode, path + ["profile_data"])
                self.solution_plot = self.__class__.solution_plot(service, version, mode, path + ["solution_plot"])
                self.xy_plot = self.__class__.xy_plot(service, version, mode, path + ["xy_plot"])
                self.plot_direction = self.__class__.plot_direction(service, version, mode, path + ["plot_direction"])
                super().__init__(service, version, mode, path)
            class plot_direction(TUIMethod):
                """
                .
                """

            class cumulative_plot(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit cumulative-plot object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class plot(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """
                class write(TUIMethod):
                    """
                    .
                    """

            class histogram(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                    self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                    self.cell_function = self.__class__.cell_function(service, version, mode, path + ["cell_function"])
                    self.maximum = self.__class__.maximum(service, version, mode, path + ["maximum"])
                    self.minimum = self.__class__.minimum(service, version, mode, path + ["minimum"])
                    self.num_divisions = self.__class__.num_divisions(service, version, mode, path + ["num_divisions"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    self.print = self.__class__.print(service, version, mode, path + ["print"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    self.zones = self.__class__.zones(service, version, mode, path + ["zones"])
                    super().__init__(service, version, mode, path)
                class auto_range(TUIMethod):
                    """
                    .
                    """
                class cell_function(TUIMethod):
                    """
                    .
                    """
                class maximum(TUIMethod):
                    """
                    .
                    """
                class minimum(TUIMethod):
                    """
                    .
                    """
                class num_divisions(TUIMethod):
                    """
                    .
                    """
                class plot(TUIMethod):
                    """
                    .
                    """
                class print(TUIMethod):
                    """
                    .
                    """
                class write(TUIMethod):
                    """
                    .
                    """
                class zones(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.x = self.__class__.x(service, version, mode, path + ["x"])
                        self.y = self.__class__.y(service, version, mode, path + ["y"])
                        self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                        super().__init__(service, version, mode, path)
                    class background_color(TUIMethod):
                        """
                        .
                        """

                    class x(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                    class y(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                class curves(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit curves object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

            class interpolated_data(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    self.x_axis_function = self.__class__.x_axis_function(service, version, mode, path + ["x_axis_function"])
                    self.y_axis_function = self.__class__.y_axis_function(service, version, mode, path + ["y_axis_function"])
                    self.zone = self.__class__.zone(service, version, mode, path + ["zone"])
                    super().__init__(service, version, mode, path)
                class plot(TUIMethod):
                    """
                    .
                    """
                class x_axis_function(TUIMethod):
                    """
                    .
                    """
                class y_axis_function(TUIMethod):
                    """
                    .
                    """
                class zone(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.x = self.__class__.x(service, version, mode, path + ["x"])
                        self.y = self.__class__.y(service, version, mode, path + ["y"])
                        self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                        super().__init__(service, version, mode, path)
                    class background_color(TUIMethod):
                        """
                        .
                        """

                    class x(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                    class y(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                class curves(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit curves object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

            class plot(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    super().__init__(service, version, mode, path)
                class plot(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.x = self.__class__.x(service, version, mode, path + ["x"])
                        self.y = self.__class__.y(service, version, mode, path + ["y"])
                        self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                        super().__init__(service, version, mode, path)
                    class background_color(TUIMethod):
                        """
                        .
                        """

                    class x(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                    class y(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                class curves(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit curves object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

            class plot_from_file(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    super().__init__(service, version, mode, path)
                class plot(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.x = self.__class__.x(service, version, mode, path + ["x"])
                        self.y = self.__class__.y(service, version, mode, path + ["y"])
                        self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                        super().__init__(service, version, mode, path)
                    class background_color(TUIMethod):
                        """
                        .
                        """

                    class x(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                    class y(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                class curves(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit curves object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

            class profile_data(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    self.profile = self.__class__.profile(service, version, mode, path + ["profile"])
                    self.x_axis_function = self.__class__.x_axis_function(service, version, mode, path + ["x_axis_function"])
                    self.y_axis_function = self.__class__.y_axis_function(service, version, mode, path + ["y_axis_function"])
                    super().__init__(service, version, mode, path)
                class plot(TUIMethod):
                    """
                    .
                    """
                class profile(TUIMethod):
                    """
                    .
                    """
                class x_axis_function(TUIMethod):
                    """
                    .
                    """
                class y_axis_function(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.x = self.__class__.x(service, version, mode, path + ["x"])
                        self.y = self.__class__.y(service, version, mode, path + ["y"])
                        self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                        super().__init__(service, version, mode, path)
                    class background_color(TUIMethod):
                        """
                        .
                        """

                    class x(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                    class y(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                class curves(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit curves object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

            class solution_plot(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                    self.field = self.__class__.field(service, version, mode, path + ["field"])
                    self.geometry = self.__class__.geometry(service, version, mode, path + ["geometry"])
                    self.node_values = self.__class__.node_values(service, version, mode, path + ["node_values"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    self.surfaces = self.__class__.surfaces(service, version, mode, path + ["surfaces"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    self.zones = self.__class__.zones(service, version, mode, path + ["zones"])
                    super().__init__(service, version, mode, path)
                class field(TUIMethod):
                    """
                    .
                    """
                class geometry(TUIMethod):
                    """
                    .
                    """
                class node_values(TUIMethod):
                    """
                    .
                    """
                class plot(TUIMethod):
                    """
                    .
                    """
                class surfaces(TUIMethod):
                    """
                    .
                    """
                class write(TUIMethod):
                    """
                    .
                    """
                class zones(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.x = self.__class__.x(service, version, mode, path + ["x"])
                        self.y = self.__class__.y(service, version, mode, path + ["y"])
                        self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                        super().__init__(service, version, mode, path)
                    class background_color(TUIMethod):
                        """
                        .
                        """

                    class x(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                    class y(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                class curves(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit curves object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

            class xy_plot(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit xy-plot object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

        class report(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.discrete_phase = self.__class__.discrete_phase(service, version, mode, path + ["discrete_phase"])
                self.flow = self.__class__.flow(service, version, mode, path + ["flow"])
                self.fluxes = self.__class__.fluxes(service, version, mode, path + ["fluxes"])
                self.heat_exchanger = self.__class__.heat_exchanger(service, version, mode, path + ["heat_exchanger"])
                self.modified_setting_options = self.__class__.modified_setting_options(service, version, mode, path + ["modified_setting_options"])
                self.population_balance = self.__class__.population_balance(service, version, mode, path + ["population_balance"])
                self.simulation_reports = self.__class__.simulation_reports(service, version, mode, path + ["simulation_reports"])
                self.surface_integrals = self.__class__.surface_integrals(service, version, mode, path + ["surface_integrals"])
                self.system = self.__class__.system(service, version, mode, path + ["system"])
                self.volume_integrals = self.__class__.volume_integrals(service, version, mode, path + ["volume_integrals"])
                self.aero_optical_distortions = self.__class__.aero_optical_distortions(service, version, mode, path + ["aero_optical_distortions"])
                self.forces = self.__class__.forces(service, version, mode, path + ["forces"])
                self.multiphase_summary = self.__class__.multiphase_summary(service, version, mode, path + ["multiphase_summary"])
                self.particle_summary = self.__class__.particle_summary(service, version, mode, path + ["particle_summary"])
                self.pathline_summary = self.__class__.pathline_summary(service, version, mode, path + ["pathline_summary"])
                self.phasic_integrals_enabled = self.__class__.phasic_integrals_enabled(service, version, mode, path + ["phasic_integrals_enabled"])
                self.projected_surface_area = self.__class__.projected_surface_area(service, version, mode, path + ["projected_surface_area"])
                self.summary = self.__class__.summary(service, version, mode, path + ["summary"])
                self.vbm = self.__class__.vbm(service, version, mode, path + ["vbm"])
                super().__init__(service, version, mode, path)
            class aero_optical_distortions(TUIMethod):
                """
                .
                """
            class forces(TUIMethod):
                """
                .
                """
            class multiphase_summary(TUIMethod):
                """
                .
                """
            class particle_summary(TUIMethod):
                """
                .
                """
            class pathline_summary(TUIMethod):
                """
                .
                """
            class phasic_integrals_enabled(TUIMethod):
                """
                .
                """
            class projected_surface_area(TUIMethod):
                """
                .
                """
            class summary(TUIMethod):
                """
                .
                """
            class vbm(TUIMethod):
                """
                .
                """

            class discrete_phase(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.histogram = self.__class__.histogram(service, version, mode, path + ["histogram"])
                    self.sample_trajectories = self.__class__.sample_trajectories(service, version, mode, path + ["sample_trajectories"])
                    self.exch_details_in_dpm_summ_rep_enabled = self.__class__.exch_details_in_dpm_summ_rep_enabled(service, version, mode, path + ["exch_details_in_dpm_summ_rep_enabled"])
                    self.extended_summary = self.__class__.extended_summary(service, version, mode, path + ["extended_summary"])
                    self.particle_summary = self.__class__.particle_summary(service, version, mode, path + ["particle_summary"])
                    self.set_per_injection_zone_summaries = self.__class__.set_per_injection_zone_summaries(service, version, mode, path + ["set_per_injection_zone_summaries"])
                    self.summary = self.__class__.summary(service, version, mode, path + ["summary"])
                    self.zone_types_to_calc_exchange_data_on = self.__class__.zone_types_to_calc_exchange_data_on(service, version, mode, path + ["zone_types_to_calc_exchange_data_on"])
                    super().__init__(service, version, mode, path)
                class exch_details_in_dpm_summ_rep_enabled(TUIMethod):
                    """
                    .
                    """
                class extended_summary(TUIMethod):
                    """
                    .
                    """
                class particle_summary(TUIMethod):
                    """
                    .
                    """
                class set_per_injection_zone_summaries(TUIMethod):
                    """
                    .
                    """
                class summary(TUIMethod):
                    """
                    .
                    """
                class zone_types_to_calc_exchange_data_on(TUIMethod):
                    """
                    .
                    """

                class histogram(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.histogram_options = self.__class__.histogram_options(service, version, mode, path + ["histogram_options"])
                        self.histogram_parameters = self.__class__.histogram_parameters(service, version, mode, path + ["histogram_parameters"])
                        self.plot_write_sample = self.__class__.plot_write_sample(service, version, mode, path + ["plot_write_sample"])
                        self.reduction = self.__class__.reduction(service, version, mode, path + ["reduction"])
                        self.compute_sample = self.__class__.compute_sample(service, version, mode, path + ["compute_sample"])
                        self.delete_sample = self.__class__.delete_sample(service, version, mode, path + ["delete_sample"])
                        self.dpm_sample_contour_plots = self.__class__.dpm_sample_contour_plots(service, version, mode, path + ["dpm_sample_contour_plots"])
                        self.list_samples = self.__class__.list_samples(service, version, mode, path + ["list_samples"])
                        self.read_sample_file = self.__class__.read_sample_file(service, version, mode, path + ["read_sample_file"])
                        super().__init__(service, version, mode, path)
                    class compute_sample(TUIMethod):
                        """
                        .
                        """
                    class delete_sample(TUIMethod):
                        """
                        .
                        """
                    class dpm_sample_contour_plots(TUIMethod):
                        """
                        .
                        """
                    class list_samples(TUIMethod):
                        """
                        .
                        """
                    class read_sample_file(TUIMethod):
                        """
                        .
                        """

                    class histogram_options(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.correlation = self.__class__.correlation(service, version, mode, path + ["correlation"])
                            self.cumulation_curve = self.__class__.cumulation_curve(service, version, mode, path + ["cumulation_curve"])
                            self.diameter_statistics = self.__class__.diameter_statistics(service, version, mode, path + ["diameter_statistics"])
                            self.histogram_mode = self.__class__.histogram_mode(service, version, mode, path + ["histogram_mode"])
                            self.logarithmic = self.__class__.logarithmic(service, version, mode, path + ["logarithmic"])
                            self.percentage = self.__class__.percentage(service, version, mode, path + ["percentage"])
                            self.variable_cubed = self.__class__.variable_cubed(service, version, mode, path + ["variable_cubed"])
                            self.weighting = self.__class__.weighting(service, version, mode, path + ["weighting"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class correlation(TUIMethod):
                            """
                            .
                            """
                        class cumulation_curve(TUIMethod):
                            """
                            .
                            """
                        class diameter_statistics(TUIMethod):
                            """
                            .
                            """
                        class histogram_mode(TUIMethod):
                            """
                            .
                            """
                        class logarithmic(TUIMethod):
                            """
                            .
                            """
                        class percentage(TUIMethod):
                            """
                            .
                            """
                        class variable_cubed(TUIMethod):
                            """
                            .
                            """
                        class weighting(TUIMethod):
                            """
                            .
                            """

                    class histogram_parameters(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.maximum_val = self.__class__.maximum_val(service, version, mode, path + ["maximum_val"])
                            self.minimum_val = self.__class__.minimum_val(service, version, mode, path + ["minimum_val"])
                            self.number_of_bins = self.__class__.number_of_bins(service, version, mode, path + ["number_of_bins"])
                            super().__init__(service, version, mode, path)
                        class maximum_val(TUIMethod):
                            """
                            .
                            """
                        class minimum_val(TUIMethod):
                            """
                            .
                            """
                        class number_of_bins(TUIMethod):
                            """
                            .
                            """

                    class plot_write_sample(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.plot_sample = self.__class__.plot_sample(service, version, mode, path + ["plot_sample"])
                            self.write_sample = self.__class__.write_sample(service, version, mode, path + ["write_sample"])
                            super().__init__(service, version, mode, path)
                        class plot_sample(TUIMethod):
                            """
                            .
                            """
                        class write_sample(TUIMethod):
                            """
                            .
                            """

                    class reduction(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.setup_reduction = self.__class__.setup_reduction(service, version, mode, path + ["setup_reduction"])
                            self.pick_sample_to_reduce = self.__class__.pick_sample_to_reduce(service, version, mode, path + ["pick_sample_to_reduce"])
                            self.reduce_picked_sample = self.__class__.reduce_picked_sample(service, version, mode, path + ["reduce_picked_sample"])
                            super().__init__(service, version, mode, path)
                        class pick_sample_to_reduce(TUIMethod):
                            """
                            .
                            """
                        class reduce_picked_sample(TUIMethod):
                            """
                            .
                            """

                        class setup_reduction(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.all_variables_number_of_bins = self.__class__.all_variables_number_of_bins(service, version, mode, path + ["all_variables_number_of_bins"])
                                self.list_settings = self.__class__.list_settings(service, version, mode, path + ["list_settings"])
                                self.make_steady_from_unsteady_file = self.__class__.make_steady_from_unsteady_file(service, version, mode, path + ["make_steady_from_unsteady_file"])
                                self.number_of_bins = self.__class__.number_of_bins(service, version, mode, path + ["number_of_bins"])
                                self.reset_min_and_max = self.__class__.reset_min_and_max(service, version, mode, path + ["reset_min_and_max"])
                                self.set_maximum = self.__class__.set_maximum(service, version, mode, path + ["set_maximum"])
                                self.set_minimum = self.__class__.set_minimum(service, version, mode, path + ["set_minimum"])
                                self.use_logarithmic = self.__class__.use_logarithmic(service, version, mode, path + ["use_logarithmic"])
                                self.use_weighting = self.__class__.use_weighting(service, version, mode, path + ["use_weighting"])
                                self.weighting_variable = self.__class__.weighting_variable(service, version, mode, path + ["weighting_variable"])
                                super().__init__(service, version, mode, path)
                            class all_variables_number_of_bins(TUIMethod):
                                """
                                .
                                """
                            class list_settings(TUIMethod):
                                """
                                .
                                """
                            class make_steady_from_unsteady_file(TUIMethod):
                                """
                                .
                                """
                            class number_of_bins(TUIMethod):
                                """
                                .
                                """
                            class reset_min_and_max(TUIMethod):
                                """
                                .
                                """
                            class set_maximum(TUIMethod):
                                """
                                .
                                """
                            class set_minimum(TUIMethod):
                                """
                                .
                                """
                            class use_logarithmic(TUIMethod):
                                """
                                .
                                """
                            class use_weighting(TUIMethod):
                                """
                                .
                                """
                            class weighting_variable(TUIMethod):
                                """
                                .
                                """

                class sample_trajectories(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.compute = self.__class__.compute(service, version, mode, path + ["compute"])
                        self.output_udf = self.__class__.output_udf(service, version, mode, path + ["output_udf"])
                        self.sort_sample_files = self.__class__.sort_sample_files(service, version, mode, path + ["sort_sample_files"])
                        self.start_file_write = self.__class__.start_file_write(service, version, mode, path + ["start_file_write"])
                        self.stop_file_write = self.__class__.stop_file_write(service, version, mode, path + ["stop_file_write"])
                        super().__init__(service, version, mode, path)
                    class compute(TUIMethod):
                        """
                        .
                        """
                    class output_udf(TUIMethod):
                        """
                        .
                        """
                    class sort_sample_files(TUIMethod):
                        """
                        .
                        """
                    class start_file_write(TUIMethod):
                        """
                        .
                        """
                    class stop_file_write(TUIMethod):
                        """
                        .
                        """

            class flow(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.element_mass_flow = self.__class__.element_mass_flow(service, version, mode, path + ["element_mass_flow"])
                    self.species_mass_flow = self.__class__.species_mass_flow(service, version, mode, path + ["species_mass_flow"])
                    self.uds_flow = self.__class__.uds_flow(service, version, mode, path + ["uds_flow"])
                    super().__init__(service, version, mode, path)
                class element_mass_flow(TUIMethod):
                    """
                    .
                    """
                class species_mass_flow(TUIMethod):
                    """
                    .
                    """
                class uds_flow(TUIMethod):
                    """
                    .
                    """

            class fluxes(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.electric_current = self.__class__.electric_current(service, version, mode, path + ["electric_current"])
                    self.film_heat_transfer = self.__class__.film_heat_transfer(service, version, mode, path + ["film_heat_transfer"])
                    self.film_mass_flow = self.__class__.film_mass_flow(service, version, mode, path + ["film_mass_flow"])
                    self.heat_transfer = self.__class__.heat_transfer(service, version, mode, path + ["heat_transfer"])
                    self.heat_transfer_sensible = self.__class__.heat_transfer_sensible(service, version, mode, path + ["heat_transfer_sensible"])
                    self.mass_flow = self.__class__.mass_flow(service, version, mode, path + ["mass_flow"])
                    self.pressure_work = self.__class__.pressure_work(service, version, mode, path + ["pressure_work"])
                    self.radiation_heat_transfer = self.__class__.radiation_heat_transfer(service, version, mode, path + ["radiation_heat_transfer"])
                    self.viscous_work = self.__class__.viscous_work(service, version, mode, path + ["viscous_work"])
                    super().__init__(service, version, mode, path)
                class electric_current(TUIMethod):
                    """
                    .
                    """
                class film_heat_transfer(TUIMethod):
                    """
                    .
                    """
                class film_mass_flow(TUIMethod):
                    """
                    .
                    """
                class heat_transfer(TUIMethod):
                    """
                    .
                    """
                class heat_transfer_sensible(TUIMethod):
                    """
                    .
                    """
                class mass_flow(TUIMethod):
                    """
                    .
                    """
                class pressure_work(TUIMethod):
                    """
                    .
                    """
                class radiation_heat_transfer(TUIMethod):
                    """
                    .
                    """
                class viscous_work(TUIMethod):
                    """
                    .
                    """

            class heat_exchanger(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.computed_heat_rejection = self.__class__.computed_heat_rejection(service, version, mode, path + ["computed_heat_rejection"])
                    self.inlet_temperature = self.__class__.inlet_temperature(service, version, mode, path + ["inlet_temperature"])
                    self.mass_flow_rate = self.__class__.mass_flow_rate(service, version, mode, path + ["mass_flow_rate"])
                    self.outlet_temperature = self.__class__.outlet_temperature(service, version, mode, path + ["outlet_temperature"])
                    self.specific_heat = self.__class__.specific_heat(service, version, mode, path + ["specific_heat"])
                    super().__init__(service, version, mode, path)
                class computed_heat_rejection(TUIMethod):
                    """
                    .
                    """
                class inlet_temperature(TUIMethod):
                    """
                    .
                    """
                class mass_flow_rate(TUIMethod):
                    """
                    .
                    """
                class outlet_temperature(TUIMethod):
                    """
                    .
                    """
                class specific_heat(TUIMethod):
                    """
                    .
                    """

            class modified_setting_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.modified_setting = self.__class__.modified_setting(service, version, mode, path + ["modified_setting"])
                    self.write_user_setting = self.__class__.write_user_setting(service, version, mode, path + ["write_user_setting"])
                    super().__init__(service, version, mode, path)
                class modified_setting(TUIMethod):
                    """
                    .
                    """
                class write_user_setting(TUIMethod):
                    """
                    .
                    """

            class population_balance(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.number_density = self.__class__.number_density(service, version, mode, path + ["number_density"])
                    self.moments = self.__class__.moments(service, version, mode, path + ["moments"])
                    super().__init__(service, version, mode, path)
                class moments(TUIMethod):
                    """
                    .
                    """

                class number_density(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.dia_upper_limit = self.__class__.dia_upper_limit(service, version, mode, path + ["dia_upper_limit"])
                        self.histogram = self.__class__.histogram(service, version, mode, path + ["histogram"])
                        self.num_dens_func = self.__class__.num_dens_func(service, version, mode, path + ["num_dens_func"])
                        self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                        self.print = self.__class__.print(service, version, mode, path + ["print"])
                        self.report_type = self.__class__.report_type(service, version, mode, path + ["report_type"])
                        self.surface_list = self.__class__.surface_list(service, version, mode, path + ["surface_list"])
                        self.volume_list = self.__class__.volume_list(service, version, mode, path + ["volume_list"])
                        self.write_to_file = self.__class__.write_to_file(service, version, mode, path + ["write_to_file"])
                        super().__init__(service, version, mode, path)
                    class dia_upper_limit(TUIMethod):
                        """
                        .
                        """
                    class histogram(TUIMethod):
                        """
                        .
                        """
                    class num_dens_func(TUIMethod):
                        """
                        .
                        """
                    class plot(TUIMethod):
                        """
                        .
                        """
                    class print(TUIMethod):
                        """
                        .
                        """
                    class report_type(TUIMethod):
                        """
                        .
                        """
                    class surface_list(TUIMethod):
                        """
                        .
                        """
                    class volume_list(TUIMethod):
                        """
                        .
                        """
                    class write_to_file(TUIMethod):
                        """
                        .
                        """

            class simulation_reports(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_histogram_to_report = self.__class__.add_histogram_to_report(service, version, mode, path + ["add_histogram_to_report"])
                    self.delete_simulation_report = self.__class__.delete_simulation_report(service, version, mode, path + ["delete_simulation_report"])
                    self.duplicate_simulation_report = self.__class__.duplicate_simulation_report(service, version, mode, path + ["duplicate_simulation_report"])
                    self.export_simulation_report_as_html = self.__class__.export_simulation_report_as_html(service, version, mode, path + ["export_simulation_report_as_html"])
                    self.export_simulation_report_as_pdf = self.__class__.export_simulation_report_as_pdf(service, version, mode, path + ["export_simulation_report_as_pdf"])
                    self.export_simulation_report_as_pptx = self.__class__.export_simulation_report_as_pptx(service, version, mode, path + ["export_simulation_report_as_pptx"])
                    self.generate_simulation_report = self.__class__.generate_simulation_report(service, version, mode, path + ["generate_simulation_report"])
                    self.list_simulation_reports = self.__class__.list_simulation_reports(service, version, mode, path + ["list_simulation_reports"])
                    self.read_simulation_report_template_file = self.__class__.read_simulation_report_template_file(service, version, mode, path + ["read_simulation_report_template_file"])
                    self.rename_simulation_report = self.__class__.rename_simulation_report(service, version, mode, path + ["rename_simulation_report"])
                    self.reset_report_to_defaults = self.__class__.reset_report_to_defaults(service, version, mode, path + ["reset_report_to_defaults"])
                    self.view_simulation_report = self.__class__.view_simulation_report(service, version, mode, path + ["view_simulation_report"])
                    self.write_simulation_report_names_to_file = self.__class__.write_simulation_report_names_to_file(service, version, mode, path + ["write_simulation_report_names_to_file"])
                    self.write_simulation_report_template_file = self.__class__.write_simulation_report_template_file(service, version, mode, path + ["write_simulation_report_template_file"])
                    super().__init__(service, version, mode, path)
                class add_histogram_to_report(TUIMethod):
                    """
                    .
                    """
                class delete_simulation_report(TUIMethod):
                    """
                    .
                    """
                class duplicate_simulation_report(TUIMethod):
                    """
                    .
                    """
                class export_simulation_report_as_html(TUIMethod):
                    """
                    .
                    """
                class export_simulation_report_as_pdf(TUIMethod):
                    """
                    .
                    """
                class export_simulation_report_as_pptx(TUIMethod):
                    """
                    .
                    """
                class generate_simulation_report(TUIMethod):
                    """
                    .
                    """
                class list_simulation_reports(TUIMethod):
                    """
                    .
                    """
                class read_simulation_report_template_file(TUIMethod):
                    """
                    .
                    """
                class rename_simulation_report(TUIMethod):
                    """
                    .
                    """
                class reset_report_to_defaults(TUIMethod):
                    """
                    .
                    """
                class view_simulation_report(TUIMethod):
                    """
                    .
                    """
                class write_simulation_report_names_to_file(TUIMethod):
                    """
                    .
                    """
                class write_simulation_report_template_file(TUIMethod):
                    """
                    .
                    """

            class surface_integrals(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.area = self.__class__.area(service, version, mode, path + ["area"])
                    self.area_weighted_avg = self.__class__.area_weighted_avg(service, version, mode, path + ["area_weighted_avg"])
                    self.facet_avg = self.__class__.facet_avg(service, version, mode, path + ["facet_avg"])
                    self.facet_max = self.__class__.facet_max(service, version, mode, path + ["facet_max"])
                    self.facet_min = self.__class__.facet_min(service, version, mode, path + ["facet_min"])
                    self.flow_rate = self.__class__.flow_rate(service, version, mode, path + ["flow_rate"])
                    self.integral = self.__class__.integral(service, version, mode, path + ["integral"])
                    self.mass_flow_rate = self.__class__.mass_flow_rate(service, version, mode, path + ["mass_flow_rate"])
                    self.mass_weighted_avg = self.__class__.mass_weighted_avg(service, version, mode, path + ["mass_weighted_avg"])
                    self.standard_deviation = self.__class__.standard_deviation(service, version, mode, path + ["standard_deviation"])
                    self.sum = self.__class__.sum(service, version, mode, path + ["sum"])
                    self.uniformity_index_area_weighted = self.__class__.uniformity_index_area_weighted(service, version, mode, path + ["uniformity_index_area_weighted"])
                    self.uniformity_index_mass_weighted = self.__class__.uniformity_index_mass_weighted(service, version, mode, path + ["uniformity_index_mass_weighted"])
                    self.vector_based_flux = self.__class__.vector_based_flux(service, version, mode, path + ["vector_based_flux"])
                    self.vector_flux = self.__class__.vector_flux(service, version, mode, path + ["vector_flux"])
                    self.vector_weighted_average = self.__class__.vector_weighted_average(service, version, mode, path + ["vector_weighted_average"])
                    self.vertex_avg = self.__class__.vertex_avg(service, version, mode, path + ["vertex_avg"])
                    self.vertex_max = self.__class__.vertex_max(service, version, mode, path + ["vertex_max"])
                    self.vertex_min = self.__class__.vertex_min(service, version, mode, path + ["vertex_min"])
                    self.volume_flow_rate = self.__class__.volume_flow_rate(service, version, mode, path + ["volume_flow_rate"])
                    super().__init__(service, version, mode, path)
                class area(TUIMethod):
                    """
                    .
                    """
                class area_weighted_avg(TUIMethod):
                    """
                    .
                    """
                class facet_avg(TUIMethod):
                    """
                    .
                    """
                class facet_max(TUIMethod):
                    """
                    .
                    """
                class facet_min(TUIMethod):
                    """
                    .
                    """
                class flow_rate(TUIMethod):
                    """
                    .
                    """
                class integral(TUIMethod):
                    """
                    .
                    """
                class mass_flow_rate(TUIMethod):
                    """
                    .
                    """
                class mass_weighted_avg(TUIMethod):
                    """
                    .
                    """
                class standard_deviation(TUIMethod):
                    """
                    .
                    """
                class sum(TUIMethod):
                    """
                    .
                    """
                class uniformity_index_area_weighted(TUIMethod):
                    """
                    .
                    """
                class uniformity_index_mass_weighted(TUIMethod):
                    """
                    .
                    """
                class vector_based_flux(TUIMethod):
                    """
                    .
                    """
                class vector_flux(TUIMethod):
                    """
                    .
                    """
                class vector_weighted_average(TUIMethod):
                    """
                    .
                    """
                class vertex_avg(TUIMethod):
                    """
                    .
                    """
                class vertex_max(TUIMethod):
                    """
                    .
                    """
                class vertex_min(TUIMethod):
                    """
                    .
                    """
                class volume_flow_rate(TUIMethod):
                    """
                    .
                    """

            class system(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.print_gpgpu_statistics = self.__class__.print_gpgpu_statistics(service, version, mode, path + ["print_gpgpu_statistics"])
                    self.print_process_statistics = self.__class__.print_process_statistics(service, version, mode, path + ["print_process_statistics"])
                    self.print_system_statistics = self.__class__.print_system_statistics(service, version, mode, path + ["print_system_statistics"])
                    self.print_time_statistics = self.__class__.print_time_statistics(service, version, mode, path + ["print_time_statistics"])
                    super().__init__(service, version, mode, path)
                class print_gpgpu_statistics(TUIMethod):
                    """
                    .
                    """
                class print_process_statistics(TUIMethod):
                    """
                    .
                    """
                class print_system_statistics(TUIMethod):
                    """
                    .
                    """
                class print_time_statistics(TUIMethod):
                    """
                    .
                    """

            class volume_integrals(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.mass = self.__class__.mass(service, version, mode, path + ["mass"])
                    self.mass_average = self.__class__.mass_average(service, version, mode, path + ["mass_average"])
                    self.mass_integral = self.__class__.mass_integral(service, version, mode, path + ["mass_integral"])
                    self.maximum = self.__class__.maximum(service, version, mode, path + ["maximum"])
                    self.minimum = self.__class__.minimum(service, version, mode, path + ["minimum"])
                    self.sum = self.__class__.sum(service, version, mode, path + ["sum"])
                    self.twopisum = self.__class__.twopisum(service, version, mode, path + ["twopisum"])
                    self.volume = self.__class__.volume(service, version, mode, path + ["volume"])
                    self.volume_average = self.__class__.volume_average(service, version, mode, path + ["volume_average"])
                    self.volume_integral = self.__class__.volume_integral(service, version, mode, path + ["volume_integral"])
                    super().__init__(service, version, mode, path)
                class mass(TUIMethod):
                    """
                    .
                    """
                class mass_average(TUIMethod):
                    """
                    .
                    """
                class mass_integral(TUIMethod):
                    """
                    .
                    """
                class maximum(TUIMethod):
                    """
                    .
                    """
                class minimum(TUIMethod):
                    """
                    .
                    """
                class sum(TUIMethod):
                    """
                    .
                    """
                class twopisum(TUIMethod):
                    """
                    .
                    """
                class volume(TUIMethod):
                    """
                    .
                    """
                class volume_average(TUIMethod):
                    """
                    .
                    """
                class volume_integral(TUIMethod):
                    """
                    .
                    """

        class scene(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                super().__init__(service, version, mode, path)
            class add_to_graphics(TUIMethod):
                """
                .
                """
            class clear_history(TUIMethod):
                """
                .
                """
            class create(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class display(TUIMethod):
                """
                .
                """
            class edit(TUIMethod):
                """
                Edit scene object.
                """
            class list(TUIMethod):
                """
                .
                """
            class list_properties(TUIMethod):
                """
                .
                """
            class make_a_copy(TUIMethod):
                """
                .
                """
            class rename(TUIMethod):
                """
                .
                """

        class surfaces(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.expression_volume = self.__class__.expression_volume(service, version, mode, path + ["expression_volume"])
                self.group_surface = self.__class__.group_surface(service, version, mode, path + ["group_surface"])
                self.imprint_surface = self.__class__.imprint_surface(service, version, mode, path + ["imprint_surface"])
                self.iso_clip = self.__class__.iso_clip(service, version, mode, path + ["iso_clip"])
                self.iso_surface = self.__class__.iso_surface(service, version, mode, path + ["iso_surface"])
                self.line_surface = self.__class__.line_surface(service, version, mode, path + ["line_surface"])
                self.partition_surface = self.__class__.partition_surface(service, version, mode, path + ["partition_surface"])
                self.plane_slice = self.__class__.plane_slice(service, version, mode, path + ["plane_slice"])
                self.plane_surface = self.__class__.plane_surface(service, version, mode, path + ["plane_surface"])
                self.point_surface = self.__class__.point_surface(service, version, mode, path + ["point_surface"])
                self.quadric_surface = self.__class__.quadric_surface(service, version, mode, path + ["quadric_surface"])
                self.rake_surface = self.__class__.rake_surface(service, version, mode, path + ["rake_surface"])
                self.sphere_slice = self.__class__.sphere_slice(service, version, mode, path + ["sphere_slice"])
                self.surface_cells = self.__class__.surface_cells(service, version, mode, path + ["surface_cells"])
                self.transform_surface = self.__class__.transform_surface(service, version, mode, path + ["transform_surface"])
                self.zone_surface = self.__class__.zone_surface(service, version, mode, path + ["zone_surface"])
                self.create_group_surfaces = self.__class__.create_group_surfaces(service, version, mode, path + ["create_group_surfaces"])
                self.create_multiple_iso_surfaces = self.__class__.create_multiple_iso_surfaces(service, version, mode, path + ["create_multiple_iso_surfaces"])
                self.create_multiple_plane_surfaces = self.__class__.create_multiple_plane_surfaces(service, version, mode, path + ["create_multiple_plane_surfaces"])
                self.create_multiple_zone_surfaces = self.__class__.create_multiple_zone_surfaces(service, version, mode, path + ["create_multiple_zone_surfaces"])
                self.reset_zone_surfaces = self.__class__.reset_zone_surfaces(service, version, mode, path + ["reset_zone_surfaces"])
                self.set_rendering_priority = self.__class__.set_rendering_priority(service, version, mode, path + ["set_rendering_priority"])
                self.ungroup_surfaces = self.__class__.ungroup_surfaces(service, version, mode, path + ["ungroup_surfaces"])
                super().__init__(service, version, mode, path)
            class create_group_surfaces(TUIMethod):
                """
                .
                """
            class create_multiple_iso_surfaces(TUIMethod):
                """
                .
                """
            class create_multiple_plane_surfaces(TUIMethod):
                """
                .
                """
            class create_multiple_zone_surfaces(TUIMethod):
                """
                .
                """
            class reset_zone_surfaces(TUIMethod):
                """
                .
                """
            class set_rendering_priority(TUIMethod):
                """
                .
                """
            class ungroup_surfaces(TUIMethod):
                """
                .
                """

            class expression_volume(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit expression-volume object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class group_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    self.ungroup = self.__class__.ungroup(service, version, mode, path + ["ungroup"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit group-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """
                class ungroup(TUIMethod):
                    """
                    .
                    """

            class imprint_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit imprint-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class iso_clip(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit iso-clip object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class iso_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit iso-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class line_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit line-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class partition_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit partition-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class plane_slice(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit plane-slice object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class plane_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit plane-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class point_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit point-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class quadric_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit quadric-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class rake_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit rake-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class sphere_slice(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit sphere-slice object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class surface_cells(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit surface-cells object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class transform_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit transform-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class zone_surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit zone-surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

    class server(TUIMenu):
        """
        Enter the server menu.
        """
        def __init__(self, service, version, mode, path):
            self.print_connected_grpc_clients = self.__class__.print_connected_grpc_clients(service, version, mode, path + ["print_connected_grpc_clients"])
            self.print_grpc_server_address = self.__class__.print_grpc_server_address(service, version, mode, path + ["print_grpc_server_address"])
            self.print_web_server_info = self.__class__.print_web_server_info(service, version, mode, path + ["print_web_server_info"])
            self.shutdown_grpc_server = self.__class__.shutdown_grpc_server(service, version, mode, path + ["shutdown_grpc_server"])
            self.start_client = self.__class__.start_client(service, version, mode, path + ["start_client"])
            self.start_grpc_server = self.__class__.start_grpc_server(service, version, mode, path + ["start_grpc_server"])
            self.start_web_server = self.__class__.start_web_server(service, version, mode, path + ["start_web_server"])
            self.stop_web_server = self.__class__.stop_web_server(service, version, mode, path + ["stop_web_server"])
            self.write_or_reset_grpc_server_info = self.__class__.write_or_reset_grpc_server_info(service, version, mode, path + ["write_or_reset_grpc_server_info"])
            super().__init__(service, version, mode, path)
        class print_connected_grpc_clients(TUIMethod):
            """
            Print connected clients.
            """
        class print_grpc_server_address(TUIMethod):
            """
            Print server address.
            """
        class print_web_server_info(TUIMethod):
            """
            .
            """
        class shutdown_grpc_server(TUIMethod):
            """
            Shutdown server.
            """
        class start_client(TUIMethod):
            """
            Start remote visualization client (deprecated).
            """
        class start_grpc_server(TUIMethod):
            """
            Start gRPC server.
            """
        class start_web_server(TUIMethod):
            """
            .
            """
        class stop_web_server(TUIMethod):
            """
            .
            """
        class write_or_reset_grpc_server_info(TUIMethod):
            """
            Write/Reset server info.
            """

    class setup(TUIMenu):
        """
        Enter setup menu.
        """
        def __init__(self, service, version, mode, path):
            self.boundary_conditions = self.__class__.boundary_conditions(service, version, mode, path + ["boundary_conditions"])
            super().__init__(service, version, mode, path)

        class boundary_conditions(TUIMenu):
            """
            Enter the boudary conditions menu.
            """
            def __init__(self, service, version, mode, path):
                self.query = self.__class__.query(service, version, mode, path + ["query"])
                super().__init__(service, version, mode, path)

            class query(TUIMenu):
                """
                Enter zone query menu.
                """
                def __init__(self, service, version, mode, path):
                    self.axis = self.__class__.axis(service, version, mode, path + ["axis"])
                    self.degassing = self.__class__.degassing(service, version, mode, path + ["degassing"])
                    self.delete_query = self.__class__.delete_query(service, version, mode, path + ["delete_query"])
                    self.exhaust_fan = self.__class__.exhaust_fan(service, version, mode, path + ["exhaust_fan"])
                    self.fan = self.__class__.fan(service, version, mode, path + ["fan"])
                    self.fluid = self.__class__.fluid(service, version, mode, path + ["fluid"])
                    self.geometry = self.__class__.geometry(service, version, mode, path + ["geometry"])
                    self.inlet_vent = self.__class__.inlet_vent(service, version, mode, path + ["inlet_vent"])
                    self.intake_fan = self.__class__.intake_fan(service, version, mode, path + ["intake_fan"])
                    self.interface = self.__class__.interface(service, version, mode, path + ["interface"])
                    self.interior = self.__class__.interior(service, version, mode, path + ["interior"])
                    self.list_boundary_conditions = self.__class__.list_boundary_conditions(service, version, mode, path + ["list_boundary_conditions"])
                    self.list_cell_zone_conditions = self.__class__.list_cell_zone_conditions(service, version, mode, path + ["list_cell_zone_conditions"])
                    self.list_named_selection = self.__class__.list_named_selection(service, version, mode, path + ["list_named_selection"])
                    self.list_queries = self.__class__.list_queries(service, version, mode, path + ["list_queries"])
                    self.mass_flow_inlet = self.__class__.mass_flow_inlet(service, version, mode, path + ["mass_flow_inlet"])
                    self.mass_flow_outlet = self.__class__.mass_flow_outlet(service, version, mode, path + ["mass_flow_outlet"])
                    self.named_zone_list = self.__class__.named_zone_list(service, version, mode, path + ["named_zone_list"])
                    self.network = self.__class__.network(service, version, mode, path + ["network"])
                    self.network_end = self.__class__.network_end(service, version, mode, path + ["network_end"])
                    self.outflow = self.__class__.outflow(service, version, mode, path + ["outflow"])
                    self.outlet_vent = self.__class__.outlet_vent(service, version, mode, path + ["outlet_vent"])
                    self.overset = self.__class__.overset(service, version, mode, path + ["overset"])
                    self.periodic = self.__class__.periodic(service, version, mode, path + ["periodic"])
                    self.porous_jump = self.__class__.porous_jump(service, version, mode, path + ["porous_jump"])
                    self.pressure_far_field = self.__class__.pressure_far_field(service, version, mode, path + ["pressure_far_field"])
                    self.pressure_inlet = self.__class__.pressure_inlet(service, version, mode, path + ["pressure_inlet"])
                    self.pressure_outlet = self.__class__.pressure_outlet(service, version, mode, path + ["pressure_outlet"])
                    self.radiator = self.__class__.radiator(service, version, mode, path + ["radiator"])
                    self.rans_les_interface = self.__class__.rans_les_interface(service, version, mode, path + ["rans_les_interface"])
                    self.recirculation_inlet = self.__class__.recirculation_inlet(service, version, mode, path + ["recirculation_inlet"])
                    self.recirculation_outlet = self.__class__.recirculation_outlet(service, version, mode, path + ["recirculation_outlet"])
                    self.shadow = self.__class__.shadow(service, version, mode, path + ["shadow"])
                    self.solid = self.__class__.solid(service, version, mode, path + ["solid"])
                    self.symmetry = self.__class__.symmetry(service, version, mode, path + ["symmetry"])
                    self.velocity_inlet = self.__class__.velocity_inlet(service, version, mode, path + ["velocity_inlet"])
                    self.wall = self.__class__.wall(service, version, mode, path + ["wall"])
                    super().__init__(service, version, mode, path)
                class axis(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class degassing(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class delete_query(TUIMethod):
                    """
                    Delete saved query.
                    """
                class exhaust_fan(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class fan(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class fluid(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class geometry(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class inlet_vent(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class intake_fan(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class interface(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class interior(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class list_boundary_conditions(TUIMethod):
                    """
                    List boundary conditions.
                    """
                class list_cell_zone_conditions(TUIMethod):
                    """
                    List cell zone conditions.
                    """
                class list_named_selection(TUIMethod):
                    """
                    List named selection of zone type.
                    """
                class list_queries(TUIMethod):
                    """
                    List all saved queries.
                    """
                class mass_flow_inlet(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class mass_flow_outlet(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class named_zone_list(TUIMethod):
                    """
                    Create named list of zones.
                    """
                class network(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class network_end(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class outflow(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class outlet_vent(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class overset(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class periodic(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class porous_jump(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class pressure_far_field(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class pressure_inlet(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class pressure_outlet(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class radiator(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class rans_les_interface(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class recirculation_inlet(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class recirculation_outlet(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class shadow(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class solid(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class symmetry(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class velocity_inlet(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """
                class wall(TUIMethod):
                    """
                    Show boundary conditions for a zone of this type.
                    """

    class solution(TUIMenu):
        """
        .
        """
        def __init__(self, service, version, mode, path):
            self.calculation_activity = self.__class__.calculation_activity(service, version, mode, path + ["calculation_activity"])
            self.cell_registers = self.__class__.cell_registers(service, version, mode, path + ["cell_registers"])
            self.controls = self.__class__.controls(service, version, mode, path + ["controls"])
            self.initialization = self.__class__.initialization(service, version, mode, path + ["initialization"])
            self.methods = self.__class__.methods(service, version, mode, path + ["methods"])
            self.monitor = self.__class__.monitor(service, version, mode, path + ["monitor"])
            self.report_definitions = self.__class__.report_definitions(service, version, mode, path + ["report_definitions"])
            self.run_calculation = self.__class__.run_calculation(service, version, mode, path + ["run_calculation"])
            super().__init__(service, version, mode, path)

        class calculation_activity(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.case_modification = self.__class__.case_modification(service, version, mode, path + ["case_modification"])
                self.execute_commands = self.__class__.execute_commands(service, version, mode, path + ["execute_commands"])
                self.poor_mesh_numerics = self.__class__.poor_mesh_numerics(service, version, mode, path + ["poor_mesh_numerics"])
                self.solution_animations = self.__class__.solution_animations(service, version, mode, path + ["solution_animations"])
                super().__init__(service, version, mode, path)

            class case_modification(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.case_modification = self.__class__.case_modification(service, version, mode, path + ["case_modification"])
                    self.initialization_method = self.__class__.initialization_method(service, version, mode, path + ["initialization_method"])
                    self.add_edit_modification = self.__class__.add_edit_modification(service, version, mode, path + ["add_edit_modification"])
                    self.automatic_initialization = self.__class__.automatic_initialization(service, version, mode, path + ["automatic_initialization"])
                    self.continue_strategy_execution = self.__class__.continue_strategy_execution(service, version, mode, path + ["continue_strategy_execution"])
                    self.copy_modification = self.__class__.copy_modification(service, version, mode, path + ["copy_modification"])
                    self.delete_modification = self.__class__.delete_modification(service, version, mode, path + ["delete_modification"])
                    self.disable_modification = self.__class__.disable_modification(service, version, mode, path + ["disable_modification"])
                    self.enable_modification = self.__class__.enable_modification(service, version, mode, path + ["enable_modification"])
                    self.enable_strategy = self.__class__.enable_strategy(service, version, mode, path + ["enable_strategy"])
                    self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                    self.execute_strategy = self.__class__.execute_strategy(service, version, mode, path + ["execute_strategy"])
                    self.export_modifications = self.__class__.export_modifications(service, version, mode, path + ["export_modifications"])
                    self.import_modifications = self.__class__.import_modifications(service, version, mode, path + ["import_modifications"])
                    super().__init__(service, version, mode, path)
                class add_edit_modification(TUIMethod):
                    """
                    .
                    """
                class automatic_initialization(TUIMethod):
                    """
                    .
                    """
                class continue_strategy_execution(TUIMethod):
                    """
                    .
                    """
                class copy_modification(TUIMethod):
                    """
                    .
                    """
                class delete_modification(TUIMethod):
                    """
                    .
                    """
                class disable_modification(TUIMethod):
                    """
                    .
                    """
                class enable_modification(TUIMethod):
                    """
                    .
                    """
                class enable_strategy(TUIMethod):
                    """
                    .
                    """
                class enabled(TUIMethod):
                    """
                    .
                    """
                class execute_strategy(TUIMethod):
                    """
                    .
                    """
                class export_modifications(TUIMethod):
                    """
                    .
                    """
                class import_modifications(TUIMethod):
                    """
                    .
                    """

                class case_modification(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.before_init_modification = self.__class__.before_init_modification(service, version, mode, path + ["before_init_modification"])
                        self.modifications = self.__class__.modifications(service, version, mode, path + ["modifications"])
                        self.original_settings = self.__class__.original_settings(service, version, mode, path + ["original_settings"])
                        super().__init__(service, version, mode, path)

                    class before_init_modification(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.active = self.__class__.active(service, version, mode, path + ["active"])
                            self.command = self.__class__.command(service, version, mode, path + ["command"])
                            self.count = self.__class__.count(service, version, mode, path + ["count"])
                            self.flowtime = self.__class__.flowtime(service, version, mode, path + ["flowtime"])
                            self.ftselected = self.__class__.ftselected(service, version, mode, path + ["ftselected"])
                            self.name = self.__class__.name(service, version, mode, path + ["name"])
                            self.python_cmd = self.__class__.python_cmd(service, version, mode, path + ["python_cmd"])
                            super().__init__(service, version, mode, path)
                        class active(TUIMethod):
                            """
                            .
                            """
                        class command(TUIMethod):
                            """
                            .
                            """
                        class count(TUIMethod):
                            """
                            .
                            """
                        class flowtime(TUIMethod):
                            """
                            .
                            """
                        class ftselected(TUIMethod):
                            """
                            .
                            """
                        class name(TUIMethod):
                            """
                            .
                            """
                        class python_cmd(TUIMethod):
                            """
                            .
                            """

                    class modifications(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                            super().__init__(service, version, mode, path)
                        class edit(TUIMethod):
                            """
                            Edit modifications object.
                            """
                        class list_properties(TUIMethod):
                            """
                            .
                            """
                        class resize(TUIMethod):
                            """
                            .
                            """

                    class original_settings(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.active = self.__class__.active(service, version, mode, path + ["active"])
                            self.command = self.__class__.command(service, version, mode, path + ["command"])
                            self.count = self.__class__.count(service, version, mode, path + ["count"])
                            self.flowtime = self.__class__.flowtime(service, version, mode, path + ["flowtime"])
                            self.ftselected = self.__class__.ftselected(service, version, mode, path + ["ftselected"])
                            self.name = self.__class__.name(service, version, mode, path + ["name"])
                            self.python_cmd = self.__class__.python_cmd(service, version, mode, path + ["python_cmd"])
                            super().__init__(service, version, mode, path)
                        class active(TUIMethod):
                            """
                            .
                            """
                        class command(TUIMethod):
                            """
                            .
                            """
                        class count(TUIMethod):
                            """
                            .
                            """
                        class flowtime(TUIMethod):
                            """
                            .
                            """
                        class ftselected(TUIMethod):
                            """
                            .
                            """
                        class name(TUIMethod):
                            """
                            .
                            """
                        class python_cmd(TUIMethod):
                            """
                            .
                            """

                class initialization_method(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.init_from_solution = self.__class__.init_from_solution(service, version, mode, path + ["init_from_solution"])
                        self.init_from_data_file = self.__class__.init_from_data_file(service, version, mode, path + ["init_from_data_file"])
                        super().__init__(service, version, mode, path)
                    class init_from_data_file(TUIMethod):
                        """
                        .
                        """

                    class init_from_solution(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.init_from_data_file = self.__class__.init_from_data_file(service, version, mode, path + ["init_from_data_file"])
                            self.option = self.__class__.option(service, version, mode, path + ["option"])
                            super().__init__(service, version, mode, path)
                        class init_from_data_file(TUIMethod):
                            """
                            .
                            """
                        class option(TUIMethod):
                            """
                            .
                            """

            class execute_commands(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.disable = self.__class__.disable(service, version, mode, path + ["disable"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.export = self.__class__.export(service, version, mode, path + ["export"])
                    self.import_ = self.__class__.import_(service, version, mode, path + ["import"])
                    super().__init__(service, version, mode, path)
                class copy(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class disable(TUIMethod):
                    """
                    .
                    """
                class enable(TUIMethod):
                    """
                    .
                    """
                class export(TUIMethod):
                    """
                    .
                    """
                class import_(TUIMethod):
                    """
                    .
                    """

            class poor_mesh_numerics(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.register_based = self.__class__.register_based(service, version, mode, path + ["register_based"])
                    super().__init__(service, version, mode, path)

                class register_based(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        self.set = self.__class__.set(service, version, mode, path + ["set"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit a definition for poor mesh numerics.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """
                    class set(TUIMethod):
                        """
                        .
                        """

            class solution_animations(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.add_to_graphics = self.__class__.add_to_graphics(service, version, mode, path + ["add_to_graphics"])
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.display = self.__class__.display(service, version, mode, path + ["display"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class add_to_graphics(TUIMethod):
                    """
                    .
                    """
                class clear_history(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class display(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit solution-animations object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

        class cell_registers(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                super().__init__(service, version, mode, path)
            class create(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class edit(TUIMethod):
                """
                Edit cell-registers object.
                """
            class list(TUIMethod):
                """
                .
                """
            class list_properties(TUIMethod):
                """
                .
                """
            class make_a_copy(TUIMethod):
                """
                .
                """
            class rename(TUIMethod):
                """
                .
                """

        class controls(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.acoustics_wave_eqn_controls = self.__class__.acoustics_wave_eqn_controls(service, version, mode, path + ["acoustics_wave_eqn_controls"])
                self.advanced = self.__class__.advanced(service, version, mode, path + ["advanced"])
                self.contact_solution_controls = self.__class__.contact_solution_controls(service, version, mode, path + ["contact_solution_controls"])
                self.equations = self.__class__.equations(service, version, mode, path + ["equations"])
                self.limits = self.__class__.limits(service, version, mode, path + ["limits"])
                self.p_v_controls = self.__class__.p_v_controls(service, version, mode, path + ["p_v_controls"])
                self.pseudo_time_explicit_relaxation_factor = self.__class__.pseudo_time_explicit_relaxation_factor(service, version, mode, path + ["pseudo_time_explicit_relaxation_factor"])
                self.pseudo_time_method_local_time_step = self.__class__.pseudo_time_method_local_time_step(service, version, mode, path + ["pseudo_time_method_local_time_step"])
                self.relaxation_factor = self.__class__.relaxation_factor(service, version, mode, path + ["relaxation_factor"])
                self.under_relaxation = self.__class__.under_relaxation(service, version, mode, path + ["under_relaxation"])
                self.zonal_pbns_solution_controls = self.__class__.zonal_pbns_solution_controls(service, version, mode, path + ["zonal_pbns_solution_controls"])
                self.courant_number = self.__class__.courant_number(service, version, mode, path + ["courant_number"])
                self.reset_amg_controls = self.__class__.reset_amg_controls(service, version, mode, path + ["reset_amg_controls"])
                self.reset_limits = self.__class__.reset_limits(service, version, mode, path + ["reset_limits"])
                self.reset_multi_stage_parameters = self.__class__.reset_multi_stage_parameters(service, version, mode, path + ["reset_multi_stage_parameters"])
                self.reset_pseudo_time_method_equations = self.__class__.reset_pseudo_time_method_equations(service, version, mode, path + ["reset_pseudo_time_method_equations"])
                self.reset_pseudo_time_method_generic = self.__class__.reset_pseudo_time_method_generic(service, version, mode, path + ["reset_pseudo_time_method_generic"])
                self.reset_pseudo_time_method_relaxations = self.__class__.reset_pseudo_time_method_relaxations(service, version, mode, path + ["reset_pseudo_time_method_relaxations"])
                self.reset_pseudo_time_method_scale_factors = self.__class__.reset_pseudo_time_method_scale_factors(service, version, mode, path + ["reset_pseudo_time_method_scale_factors"])
                self.reset_solution_controls = self.__class__.reset_solution_controls(service, version, mode, path + ["reset_solution_controls"])
                self.species_urf_together = self.__class__.species_urf_together(service, version, mode, path + ["species_urf_together"])
                super().__init__(service, version, mode, path)
            class courant_number(TUIMethod):
                """
                .
                """
            class reset_amg_controls(TUIMethod):
                """
                .
                """
            class reset_limits(TUIMethod):
                """
                .
                """
            class reset_multi_stage_parameters(TUIMethod):
                """
                .
                """
            class reset_pseudo_time_method_equations(TUIMethod):
                """
                .
                """
            class reset_pseudo_time_method_generic(TUIMethod):
                """
                .
                """
            class reset_pseudo_time_method_relaxations(TUIMethod):
                """
                .
                """
            class reset_pseudo_time_method_scale_factors(TUIMethod):
                """
                .
                """
            class reset_solution_controls(TUIMethod):
                """
                .
                """
            class species_urf_together(TUIMethod):
                """
                .
                """

            class acoustics_wave_eqn_controls(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.max_iter_per_timestep_count = self.__class__.max_iter_per_timestep_count(service, version, mode, path + ["max_iter_per_timestep_count"])
                    self.relative_convergence_criterion = self.__class__.relative_convergence_criterion(service, version, mode, path + ["relative_convergence_criterion"])
                    super().__init__(service, version, mode, path)
                class max_iter_per_timestep_count(TUIMethod):
                    """
                    .
                    """
                class relative_convergence_criterion(TUIMethod):
                    """
                    .
                    """

                class expert(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.explicit_relaxation_factor = self.__class__.explicit_relaxation_factor(service, version, mode, path + ["explicit_relaxation_factor"])
                        self.under_relaxation_factor = self.__class__.under_relaxation_factor(service, version, mode, path + ["under_relaxation_factor"])
                        super().__init__(service, version, mode, path)
                    class explicit_relaxation_factor(TUIMethod):
                        """
                        .
                        """
                    class under_relaxation_factor(TUIMethod):
                        """
                        .
                        """

            class advanced(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.anisotropic_solid_heat_transfer = self.__class__.anisotropic_solid_heat_transfer(service, version, mode, path + ["anisotropic_solid_heat_transfer"])
                    self.continuity_transient_term_linearization = self.__class__.continuity_transient_term_linearization(service, version, mode, path + ["continuity_transient_term_linearization"])
                    self.correction_tolerance = self.__class__.correction_tolerance(service, version, mode, path + ["correction_tolerance"])
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.fast_transient_settings = self.__class__.fast_transient_settings(service, version, mode, path + ["fast_transient_settings"])
                    self.multi_grid = self.__class__.multi_grid(service, version, mode, path + ["multi_grid"])
                    self.multi_stage = self.__class__.multi_stage(service, version, mode, path + ["multi_stage"])
                    self.enthalpy_reference_temperature = self.__class__.enthalpy_reference_temperature(service, version, mode, path + ["enthalpy_reference_temperature"])
                    self.relaxation_method = self.__class__.relaxation_method(service, version, mode, path + ["relaxation_method"])
                    super().__init__(service, version, mode, path)
                class enthalpy_reference_temperature(TUIMethod):
                    """
                    .
                    """
                class relaxation_method(TUIMethod):
                    """
                    .
                    """

                class anisotropic_solid_heat_transfer(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.flux = self.__class__.flux(service, version, mode, path + ["flux"])
                        self.gradient = self.__class__.gradient(service, version, mode, path + ["gradient"])
                        self.relaxation = self.__class__.relaxation(service, version, mode, path + ["relaxation"])
                        super().__init__(service, version, mode, path)
                    class flux(TUIMethod):
                        """
                        .
                        """
                    class gradient(TUIMethod):
                        """
                        .
                        """
                    class relaxation(TUIMethod):
                        """
                        .
                        """

                class continuity_transient_term_linearization(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.linearize = self.__class__.linearize(service, version, mode, path + ["linearize"])
                        self.threshold = self.__class__.threshold(service, version, mode, path + ["threshold"])
                        super().__init__(service, version, mode, path)
                    class linearize(TUIMethod):
                        """
                        .
                        """
                    class threshold(TUIMethod):
                        """
                        .
                        """

                class correction_tolerance(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit correction-tolerance object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

                class expert(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.nci_secondary_gradient = self.__class__.nci_secondary_gradient(service, version, mode, path + ["nci_secondary_gradient"])
                        self.pseudo_time_method_usage = self.__class__.pseudo_time_method_usage(service, version, mode, path + ["pseudo_time_method_usage"])
                        self.spatial_discretization_limiter = self.__class__.spatial_discretization_limiter(service, version, mode, path + ["spatial_discretization_limiter"])
                        self.allow_all_disc_schemes = self.__class__.allow_all_disc_schemes(service, version, mode, path + ["allow_all_disc_schemes"])
                        self.explicit_under_relaxation_value = self.__class__.explicit_under_relaxation_value(service, version, mode, path + ["explicit_under_relaxation_value"])
                        self.keep_temporary_memory = self.__class__.keep_temporary_memory(service, version, mode, path + ["keep_temporary_memory"])
                        self.linearized_mass_transfer_udf = self.__class__.linearized_mass_transfer_udf(service, version, mode, path + ["linearized_mass_transfer_udf"])
                        self.save_cell_residuals = self.__class__.save_cell_residuals(service, version, mode, path + ["save_cell_residuals"])
                        self.singhal_cavitation_model = self.__class__.singhal_cavitation_model(service, version, mode, path + ["singhal_cavitation_model"])
                        self.wall_temp_alternate_formulation = self.__class__.wall_temp_alternate_formulation(service, version, mode, path + ["wall_temp_alternate_formulation"])
                        super().__init__(service, version, mode, path)
                    class allow_all_disc_schemes(TUIMethod):
                        """
                        .
                        """
                    class explicit_under_relaxation_value(TUIMethod):
                        """
                        .
                        """
                    class keep_temporary_memory(TUIMethod):
                        """
                        .
                        """
                    class linearized_mass_transfer_udf(TUIMethod):
                        """
                        .
                        """
                    class save_cell_residuals(TUIMethod):
                        """
                        .
                        """
                    class singhal_cavitation_model(TUIMethod):
                        """
                        .
                        """
                    class wall_temp_alternate_formulation(TUIMethod):
                        """
                        .
                        """

                    class nci_secondary_gradient(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.create = self.__class__.create(service, version, mode, path + ["create"])
                            self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                            self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                            super().__init__(service, version, mode, path)
                        class create(TUIMethod):
                            """
                            .
                            """
                        class delete(TUIMethod):
                            """
                            .
                            """
                        class edit(TUIMethod):
                            """
                            Edit nci-secondary-gradient object.
                            """
                        class list(TUIMethod):
                            """
                            .
                            """
                        class list_properties(TUIMethod):
                            """
                            .
                            """
                        class make_a_copy(TUIMethod):
                            """
                            .
                            """
                        class rename(TUIMethod):
                            """
                            .
                            """

                    class pseudo_time_method_usage(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.global_dt = self.__class__.global_dt(service, version, mode, path + ["global_dt"])
                            self.local_dt = self.__class__.local_dt(service, version, mode, path + ["local_dt"])
                            super().__init__(service, version, mode, path)

                        class global_dt(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.create = self.__class__.create(service, version, mode, path + ["create"])
                                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                                self.list = self.__class__.list(service, version, mode, path + ["list"])
                                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                                super().__init__(service, version, mode, path)
                            class create(TUIMethod):
                                """
                                .
                                """
                            class delete(TUIMethod):
                                """
                                .
                                """
                            class edit(TUIMethod):
                                """
                                Edit global-dt object.
                                """
                            class list(TUIMethod):
                                """
                                .
                                """
                            class list_properties(TUIMethod):
                                """
                                .
                                """
                            class make_a_copy(TUIMethod):
                                """
                                .
                                """
                            class rename(TUIMethod):
                                """
                                .
                                """

                        class local_dt(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.create = self.__class__.create(service, version, mode, path + ["create"])
                                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                                self.list = self.__class__.list(service, version, mode, path + ["list"])
                                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                                super().__init__(service, version, mode, path)
                            class create(TUIMethod):
                                """
                                .
                                """
                            class delete(TUIMethod):
                                """
                                .
                                """
                            class edit(TUIMethod):
                                """
                                Edit local-dt object.
                                """
                            class list(TUIMethod):
                                """
                                .
                                """
                            class list_properties(TUIMethod):
                                """
                                .
                                """
                            class make_a_copy(TUIMethod):
                                """
                                .
                                """
                            class rename(TUIMethod):
                                """
                                .
                                """

                    class spatial_discretization_limiter(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.cell_to_limiting = self.__class__.cell_to_limiting(service, version, mode, path + ["cell_to_limiting"])
                            self.limiter_filter = self.__class__.limiter_filter(service, version, mode, path + ["limiter_filter"])
                            self.limiter_type = self.__class__.limiter_type(service, version, mode, path + ["limiter_type"])
                            super().__init__(service, version, mode, path)
                        class cell_to_limiting(TUIMethod):
                            """
                            .
                            """
                        class limiter_filter(TUIMethod):
                            """
                            .
                            """
                        class limiter_type(TUIMethod):
                            """
                            .
                            """

                class fast_transient_settings(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.runge_kutta = self.__class__.runge_kutta(service, version, mode, path + ["runge_kutta"])
                        self.update_stage_gradients = self.__class__.update_stage_gradients(service, version, mode, path + ["update_stage_gradients"])
                        super().__init__(service, version, mode, path)
                    class update_stage_gradients(TUIMethod):
                        """
                        .
                        """

                    class runge_kutta(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.default_multi_stage = self.__class__.default_multi_stage(service, version, mode, path + ["default_multi_stage"])
                            self.ten_stage = self.__class__.ten_stage(service, version, mode, path + ["ten_stage"])
                            self.two_stage = self.__class__.two_stage(service, version, mode, path + ["two_stage"])
                            super().__init__(service, version, mode, path)
                        class default_multi_stage(TUIMethod):
                            """
                            .
                            """
                        class ten_stage(TUIMethod):
                            """
                            .
                            """
                        class two_stage(TUIMethod):
                            """
                            .
                            """

                class multi_grid(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.amg_controls = self.__class__.amg_controls(service, version, mode, path + ["amg_controls"])
                        self.amg_gpgpu_options = self.__class__.amg_gpgpu_options(service, version, mode, path + ["amg_gpgpu_options"])
                        self.fas_mg_controls = self.__class__.fas_mg_controls(service, version, mode, path + ["fas_mg_controls"])
                        self.mg_controls = self.__class__.mg_controls(service, version, mode, path + ["mg_controls"])
                        super().__init__(service, version, mode, path)

                    class amg_controls(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.coupled_parameters = self.__class__.coupled_parameters(service, version, mode, path + ["coupled_parameters"])
                            self.flexible_cycle_parameters = self.__class__.flexible_cycle_parameters(service, version, mode, path + ["flexible_cycle_parameters"])
                            self.options = self.__class__.options(service, version, mode, path + ["options"])
                            self.scalar_parameters = self.__class__.scalar_parameters(service, version, mode, path + ["scalar_parameters"])
                            super().__init__(service, version, mode, path)

                        class coupled_parameters(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.coarsening_parameters = self.__class__.coarsening_parameters(service, version, mode, path + ["coarsening_parameters"])
                                self.fixed_cycle_parameters = self.__class__.fixed_cycle_parameters(service, version, mode, path + ["fixed_cycle_parameters"])
                                self.smoother_type = self.__class__.smoother_type(service, version, mode, path + ["smoother_type"])
                                super().__init__(service, version, mode, path)
                            class smoother_type(TUIMethod):
                                """
                                .
                                """

                            class coarsening_parameters(TUIMenu):
                                """
                                .
                                """
                                def __init__(self, service, version, mode, path):
                                    self.aggressive_coarsening = self.__class__.aggressive_coarsening(service, version, mode, path + ["aggressive_coarsening"])
                                    self.coarsen_by_interval = self.__class__.coarsen_by_interval(service, version, mode, path + ["coarsen_by_interval"])
                                    self.conservative_coarsening = self.__class__.conservative_coarsening(service, version, mode, path + ["conservative_coarsening"])
                                    self.laplace_coarsening = self.__class__.laplace_coarsening(service, version, mode, path + ["laplace_coarsening"])
                                    self.max_coarse_levels = self.__class__.max_coarse_levels(service, version, mode, path + ["max_coarse_levels"])
                                    super().__init__(service, version, mode, path)
                                class aggressive_coarsening(TUIMethod):
                                    """
                                    .
                                    """
                                class coarsen_by_interval(TUIMethod):
                                    """
                                    .
                                    """
                                class conservative_coarsening(TUIMethod):
                                    """
                                    .
                                    """
                                class laplace_coarsening(TUIMethod):
                                    """
                                    .
                                    """
                                class max_coarse_levels(TUIMethod):
                                    """
                                    .
                                    """

                            class fixed_cycle_parameters(TUIMenu):
                                """
                                .
                                """
                                def __init__(self, service, version, mode, path):
                                    self.max_cycle = self.__class__.max_cycle(service, version, mode, path + ["max_cycle"])
                                    self.post_sweeps = self.__class__.post_sweeps(service, version, mode, path + ["post_sweeps"])
                                    self.pre_sweeps = self.__class__.pre_sweeps(service, version, mode, path + ["pre_sweeps"])
                                    super().__init__(service, version, mode, path)
                                class max_cycle(TUIMethod):
                                    """
                                    .
                                    """
                                class post_sweeps(TUIMethod):
                                    """
                                    .
                                    """
                                class pre_sweeps(TUIMethod):
                                    """
                                    .
                                    """

                        class flexible_cycle_parameters(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.max_coarse_relaxations = self.__class__.max_coarse_relaxations(service, version, mode, path + ["max_coarse_relaxations"])
                                self.max_fine_relaxations = self.__class__.max_fine_relaxations(service, version, mode, path + ["max_fine_relaxations"])
                                self.sweeps = self.__class__.sweeps(service, version, mode, path + ["sweeps"])
                                super().__init__(service, version, mode, path)
                            class max_coarse_relaxations(TUIMethod):
                                """
                                .
                                """
                            class max_fine_relaxations(TUIMethod):
                                """
                                .
                                """
                            class sweeps(TUIMethod):
                                """
                                .
                                """

                        class options(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                                super().__init__(service, version, mode, path)
                            class verbosity(TUIMethod):
                                """
                                .
                                """

                        class scalar_parameters(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.coarsening_parameters = self.__class__.coarsening_parameters(service, version, mode, path + ["coarsening_parameters"])
                                self.fixed_cycle_parameters = self.__class__.fixed_cycle_parameters(service, version, mode, path + ["fixed_cycle_parameters"])
                                self.smoother_type = self.__class__.smoother_type(service, version, mode, path + ["smoother_type"])
                                super().__init__(service, version, mode, path)
                            class smoother_type(TUIMethod):
                                """
                                .
                                """

                            class coarsening_parameters(TUIMenu):
                                """
                                .
                                """
                                def __init__(self, service, version, mode, path):
                                    self.aggressive_coarsening = self.__class__.aggressive_coarsening(service, version, mode, path + ["aggressive_coarsening"])
                                    self.coarsen_by_interval = self.__class__.coarsen_by_interval(service, version, mode, path + ["coarsen_by_interval"])
                                    self.conservative_coarsening = self.__class__.conservative_coarsening(service, version, mode, path + ["conservative_coarsening"])
                                    self.laplace_coarsening = self.__class__.laplace_coarsening(service, version, mode, path + ["laplace_coarsening"])
                                    self.max_coarse_levels = self.__class__.max_coarse_levels(service, version, mode, path + ["max_coarse_levels"])
                                    super().__init__(service, version, mode, path)
                                class aggressive_coarsening(TUIMethod):
                                    """
                                    .
                                    """
                                class coarsen_by_interval(TUIMethod):
                                    """
                                    .
                                    """
                                class conservative_coarsening(TUIMethod):
                                    """
                                    .
                                    """
                                class laplace_coarsening(TUIMethod):
                                    """
                                    .
                                    """
                                class max_coarse_levels(TUIMethod):
                                    """
                                    .
                                    """

                            class fixed_cycle_parameters(TUIMenu):
                                """
                                .
                                """
                                def __init__(self, service, version, mode, path):
                                    self.max_cycle = self.__class__.max_cycle(service, version, mode, path + ["max_cycle"])
                                    self.post_sweeps = self.__class__.post_sweeps(service, version, mode, path + ["post_sweeps"])
                                    self.pre_sweeps = self.__class__.pre_sweeps(service, version, mode, path + ["pre_sweeps"])
                                    super().__init__(service, version, mode, path)
                                class max_cycle(TUIMethod):
                                    """
                                    .
                                    """
                                class post_sweeps(TUIMethod):
                                    """
                                    .
                                    """
                                class pre_sweeps(TUIMethod):
                                    """
                                    .
                                    """

                    class amg_gpgpu_options(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.create = self.__class__.create(service, version, mode, path + ["create"])
                            self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                            self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                            super().__init__(service, version, mode, path)
                        class create(TUIMethod):
                            """
                            .
                            """
                        class delete(TUIMethod):
                            """
                            .
                            """
                        class edit(TUIMethod):
                            """
                            Edit amg-gpgpu-options object.
                            """
                        class list(TUIMethod):
                            """
                            .
                            """
                        class list_properties(TUIMethod):
                            """
                            .
                            """
                        class make_a_copy(TUIMethod):
                            """
                            .
                            """
                        class rename(TUIMethod):
                            """
                            .
                            """

                    class fas_mg_controls(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.coarsening_parameters = self.__class__.coarsening_parameters(service, version, mode, path + ["coarsening_parameters"])
                            self.fixed_cycle_parameters = self.__class__.fixed_cycle_parameters(service, version, mode, path + ["fixed_cycle_parameters"])
                            self.options = self.__class__.options(service, version, mode, path + ["options"])
                            self.relaxation_factor = self.__class__.relaxation_factor(service, version, mode, path + ["relaxation_factor"])
                            super().__init__(service, version, mode, path)

                        class coarsening_parameters(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.coarsen_by_interval = self.__class__.coarsen_by_interval(service, version, mode, path + ["coarsen_by_interval"])
                                self.max_coarse_levels = self.__class__.max_coarse_levels(service, version, mode, path + ["max_coarse_levels"])
                                super().__init__(service, version, mode, path)
                            class coarsen_by_interval(TUIMethod):
                                """
                                .
                                """
                            class max_coarse_levels(TUIMethod):
                                """
                                .
                                """

                        class fixed_cycle_parameters(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.post_sweeps = self.__class__.post_sweeps(service, version, mode, path + ["post_sweeps"])
                                self.pre_sweeps = self.__class__.pre_sweeps(service, version, mode, path + ["pre_sweeps"])
                                super().__init__(service, version, mode, path)
                            class post_sweeps(TUIMethod):
                                """
                                .
                                """
                            class pre_sweeps(TUIMethod):
                                """
                                .
                                """

                        class options(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                                super().__init__(service, version, mode, path)
                            class verbosity(TUIMethod):
                                """
                                .
                                """

                        class relaxation_factor(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.correction_reduction = self.__class__.correction_reduction(service, version, mode, path + ["correction_reduction"])
                                self.correction_smoothing = self.__class__.correction_smoothing(service, version, mode, path + ["correction_smoothing"])
                                self.courant_number_reduction = self.__class__.courant_number_reduction(service, version, mode, path + ["courant_number_reduction"])
                                self.species_correction_reduction = self.__class__.species_correction_reduction(service, version, mode, path + ["species_correction_reduction"])
                                super().__init__(service, version, mode, path)
                            class correction_reduction(TUIMethod):
                                """
                                .
                                """
                            class correction_smoothing(TUIMethod):
                                """
                                .
                                """
                            class courant_number_reduction(TUIMethod):
                                """
                                .
                                """
                            class species_correction_reduction(TUIMethod):
                                """
                                .
                                """

                    class mg_controls(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.create = self.__class__.create(service, version, mode, path + ["create"])
                            self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                            self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                            super().__init__(service, version, mode, path)
                        class create(TUIMethod):
                            """
                            .
                            """
                        class delete(TUIMethod):
                            """
                            .
                            """
                        class edit(TUIMethod):
                            """
                            Edit mg-controls object.
                            """
                        class list(TUIMethod):
                            """
                            .
                            """
                        class list_properties(TUIMethod):
                            """
                            .
                            """
                        class make_a_copy(TUIMethod):
                            """
                            .
                            """
                        class rename(TUIMethod):
                            """
                            .
                            """

                class multi_stage(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit multi-stage object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

            class contact_solution_controls(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.amg = self.__class__.amg(service, version, mode, path + ["amg"])
                    self.methods = self.__class__.methods(service, version, mode, path + ["methods"])
                    self.miscellaneous = self.__class__.miscellaneous(service, version, mode, path + ["miscellaneous"])
                    self.models = self.__class__.models(service, version, mode, path + ["models"])
                    self.parameters = self.__class__.parameters(service, version, mode, path + ["parameters"])
                    self.spatial = self.__class__.spatial(service, version, mode, path + ["spatial"])
                    self.transient = self.__class__.transient(service, version, mode, path + ["transient"])
                    self.set_settings_to_default = self.__class__.set_settings_to_default(service, version, mode, path + ["set_settings_to_default"])
                    self.solution_stabilization = self.__class__.solution_stabilization(service, version, mode, path + ["solution_stabilization"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class set_settings_to_default(TUIMethod):
                    """
                    .
                    """
                class solution_stabilization(TUIMethod):
                    """
                    .
                    """
                class verbosity(TUIMethod):
                    """
                    .
                    """

                class amg(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.coarsen_rate = self.__class__.coarsen_rate(service, version, mode, path + ["coarsen_rate"])
                        self.enforce_laplace_coarsening = self.__class__.enforce_laplace_coarsening(service, version, mode, path + ["enforce_laplace_coarsening"])
                        self.increase_pre_sweeps = self.__class__.increase_pre_sweeps(service, version, mode, path + ["increase_pre_sweeps"])
                        self.pre_sweeps = self.__class__.pre_sweeps(service, version, mode, path + ["pre_sweeps"])
                        self.specify_coarsening_rate = self.__class__.specify_coarsening_rate(service, version, mode, path + ["specify_coarsening_rate"])
                        super().__init__(service, version, mode, path)
                    class coarsen_rate(TUIMethod):
                        """
                        .
                        """
                    class enforce_laplace_coarsening(TUIMethod):
                        """
                        .
                        """
                    class increase_pre_sweeps(TUIMethod):
                        """
                        .
                        """
                    class pre_sweeps(TUIMethod):
                        """
                        .
                        """
                    class specify_coarsening_rate(TUIMethod):
                        """
                        .
                        """

                class methods(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.gradient_controls = self.__class__.gradient_controls(service, version, mode, path + ["gradient_controls"])
                        self.pv_coupling_controls = self.__class__.pv_coupling_controls(service, version, mode, path + ["pv_coupling_controls"])
                        self.pv_coupling_method = self.__class__.pv_coupling_method(service, version, mode, path + ["pv_coupling_method"])
                        self.specify_gradient_method = self.__class__.specify_gradient_method(service, version, mode, path + ["specify_gradient_method"])
                        super().__init__(service, version, mode, path)
                    class gradient_controls(TUIMethod):
                        """
                        .
                        """
                    class pv_coupling_controls(TUIMethod):
                        """
                        .
                        """
                    class pv_coupling_method(TUIMethod):
                        """
                        .
                        """
                    class specify_gradient_method(TUIMethod):
                        """
                        .
                        """

                class miscellaneous(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.compute_statistics = self.__class__.compute_statistics(service, version, mode, path + ["compute_statistics"])
                        self.statistics_level = self.__class__.statistics_level(service, version, mode, path + ["statistics_level"])
                        super().__init__(service, version, mode, path)
                    class compute_statistics(TUIMethod):
                        """
                        .
                        """
                    class statistics_level(TUIMethod):
                        """
                        .
                        """

                class models(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.model_ramping = self.__class__.model_ramping(service, version, mode, path + ["model_ramping"])
                        self.ramp_flow = self.__class__.ramp_flow(service, version, mode, path + ["ramp_flow"])
                        self.ramp_scalars = self.__class__.ramp_scalars(service, version, mode, path + ["ramp_scalars"])
                        self.ramp_turbulence = self.__class__.ramp_turbulence(service, version, mode, path + ["ramp_turbulence"])
                        super().__init__(service, version, mode, path)
                    class model_ramping(TUIMethod):
                        """
                        .
                        """
                    class ramp_flow(TUIMethod):
                        """
                        .
                        """
                    class ramp_scalars(TUIMethod):
                        """
                        .
                        """
                    class ramp_turbulence(TUIMethod):
                        """
                        .
                        """

                class parameters(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.extrapolation_method = self.__class__.extrapolation_method(service, version, mode, path + ["extrapolation_method"])
                        self.iter_count = self.__class__.iter_count(service, version, mode, path + ["iter_count"])
                        self.persistence_fixed_duration = self.__class__.persistence_fixed_duration(service, version, mode, path + ["persistence_fixed_duration"])
                        self.persistence_fixed_time_steps = self.__class__.persistence_fixed_time_steps(service, version, mode, path + ["persistence_fixed_time_steps"])
                        self.solution_stabilization_persistence = self.__class__.solution_stabilization_persistence(service, version, mode, path + ["solution_stabilization_persistence"])
                        super().__init__(service, version, mode, path)
                    class extrapolation_method(TUIMethod):
                        """
                        .
                        """
                    class iter_count(TUIMethod):
                        """
                        .
                        """
                    class persistence_fixed_duration(TUIMethod):
                        """
                        .
                        """
                    class persistence_fixed_time_steps(TUIMethod):
                        """
                        .
                        """
                    class solution_stabilization_persistence(TUIMethod):
                        """
                        .
                        """

                class spatial(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.first_to_second_order_blending = self.__class__.first_to_second_order_blending(service, version, mode, path + ["first_to_second_order_blending"])
                        self.first_to_second_order_blending_list = self.__class__.first_to_second_order_blending_list(service, version, mode, path + ["first_to_second_order_blending_list"])
                        self.flow_skew_diffusion_exclude = self.__class__.flow_skew_diffusion_exclude(service, version, mode, path + ["flow_skew_diffusion_exclude"])
                        self.rhie_chow_flux_specify = self.__class__.rhie_chow_flux_specify(service, version, mode, path + ["rhie_chow_flux_specify"])
                        self.rhie_chow_method = self.__class__.rhie_chow_method(service, version, mode, path + ["rhie_chow_method"])
                        self.scalars_skew_diffusion_exclude = self.__class__.scalars_skew_diffusion_exclude(service, version, mode, path + ["scalars_skew_diffusion_exclude"])
                        self.scheme = self.__class__.scheme(service, version, mode, path + ["scheme"])
                        super().__init__(service, version, mode, path)
                    class first_to_second_order_blending(TUIMethod):
                        """
                        .
                        """
                    class first_to_second_order_blending_list(TUIMethod):
                        """
                        .
                        """
                    class flow_skew_diffusion_exclude(TUIMethod):
                        """
                        .
                        """
                    class rhie_chow_flux_specify(TUIMethod):
                        """
                        .
                        """
                    class rhie_chow_method(TUIMethod):
                        """
                        .
                        """
                    class scalars_skew_diffusion_exclude(TUIMethod):
                        """
                        .
                        """
                    class scheme(TUIMethod):
                        """
                        .
                        """

                class transient(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.time_scale_modification_factor = self.__class__.time_scale_modification_factor(service, version, mode, path + ["time_scale_modification_factor"])
                        self.time_scale_modification_method = self.__class__.time_scale_modification_method(service, version, mode, path + ["time_scale_modification_method"])
                        self.transient_parameters_specify = self.__class__.transient_parameters_specify(service, version, mode, path + ["transient_parameters_specify"])
                        self.transient_scheme = self.__class__.transient_scheme(service, version, mode, path + ["transient_scheme"])
                        super().__init__(service, version, mode, path)
                    class time_scale_modification_factor(TUIMethod):
                        """
                        .
                        """
                    class time_scale_modification_method(TUIMethod):
                        """
                        .
                        """
                    class transient_parameters_specify(TUIMethod):
                        """
                        .
                        """
                    class transient_scheme(TUIMethod):
                        """
                        .
                        """

            class equations(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit equations object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class limits(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.max_pressure = self.__class__.max_pressure(service, version, mode, path + ["max_pressure"])
                    self.max_temperature = self.__class__.max_temperature(service, version, mode, path + ["max_temperature"])
                    self.max_turb_visc_ratio = self.__class__.max_turb_visc_ratio(service, version, mode, path + ["max_turb_visc_ratio"])
                    self.min_des_epsilon = self.__class__.min_des_epsilon(service, version, mode, path + ["min_des_epsilon"])
                    self.min_des_omega = self.__class__.min_des_omega(service, version, mode, path + ["min_des_omega"])
                    self.min_des_tke = self.__class__.min_des_tke(service, version, mode, path + ["min_des_tke"])
                    self.min_elliptic_relax_func = self.__class__.min_elliptic_relax_func(service, version, mode, path + ["min_elliptic_relax_func"])
                    self.min_epsilon = self.__class__.min_epsilon(service, version, mode, path + ["min_epsilon"])
                    self.min_lam_tke = self.__class__.min_lam_tke(service, version, mode, path + ["min_lam_tke"])
                    self.min_omega = self.__class__.min_omega(service, version, mode, path + ["min_omega"])
                    self.min_pressure = self.__class__.min_pressure(service, version, mode, path + ["min_pressure"])
                    self.min_temperature = self.__class__.min_temperature(service, version, mode, path + ["min_temperature"])
                    self.min_tke = self.__class__.min_tke(service, version, mode, path + ["min_tke"])
                    self.min_v2f_epsilon = self.__class__.min_v2f_epsilon(service, version, mode, path + ["min_v2f_epsilon"])
                    self.min_v2f_tke = self.__class__.min_v2f_tke(service, version, mode, path + ["min_v2f_tke"])
                    self.min_vel_var_scale = self.__class__.min_vel_var_scale(service, version, mode, path + ["min_vel_var_scale"])
                    self.min_vol_frac_for_matrix_sol = self.__class__.min_vol_frac_for_matrix_sol(service, version, mode, path + ["min_vol_frac_for_matrix_sol"])
                    self.positivity_rate = self.__class__.positivity_rate(service, version, mode, path + ["positivity_rate"])
                    super().__init__(service, version, mode, path)
                class max_pressure(TUIMethod):
                    """
                    .
                    """
                class max_temperature(TUIMethod):
                    """
                    .
                    """
                class max_turb_visc_ratio(TUIMethod):
                    """
                    .
                    """
                class min_des_epsilon(TUIMethod):
                    """
                    .
                    """
                class min_des_omega(TUIMethod):
                    """
                    .
                    """
                class min_des_tke(TUIMethod):
                    """
                    .
                    """
                class min_elliptic_relax_func(TUIMethod):
                    """
                    .
                    """
                class min_epsilon(TUIMethod):
                    """
                    .
                    """
                class min_lam_tke(TUIMethod):
                    """
                    .
                    """
                class min_omega(TUIMethod):
                    """
                    .
                    """
                class min_pressure(TUIMethod):
                    """
                    .
                    """
                class min_temperature(TUIMethod):
                    """
                    .
                    """
                class min_tke(TUIMethod):
                    """
                    .
                    """
                class min_v2f_epsilon(TUIMethod):
                    """
                    .
                    """
                class min_v2f_tke(TUIMethod):
                    """
                    .
                    """
                class min_vel_var_scale(TUIMethod):
                    """
                    .
                    """
                class min_vol_frac_for_matrix_sol(TUIMethod):
                    """
                    .
                    """
                class positivity_rate(TUIMethod):
                    """
                    .
                    """

            class p_v_controls(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.explicit_momentum_under_relaxation = self.__class__.explicit_momentum_under_relaxation(service, version, mode, path + ["explicit_momentum_under_relaxation"])
                    self.explicit_pressure_under_relaxation = self.__class__.explicit_pressure_under_relaxation(service, version, mode, path + ["explicit_pressure_under_relaxation"])
                    self.explicit_volume_fraction_under_relaxation = self.__class__.explicit_volume_fraction_under_relaxation(service, version, mode, path + ["explicit_volume_fraction_under_relaxation"])
                    self.flow_courant_number = self.__class__.flow_courant_number(service, version, mode, path + ["flow_courant_number"])
                    self.neighbor_correction_itr_count = self.__class__.neighbor_correction_itr_count(service, version, mode, path + ["neighbor_correction_itr_count"])
                    self.skewness_correction_itr_count = self.__class__.skewness_correction_itr_count(service, version, mode, path + ["skewness_correction_itr_count"])
                    self.skewness_neighbor_coupling = self.__class__.skewness_neighbor_coupling(service, version, mode, path + ["skewness_neighbor_coupling"])
                    self.vof_correction_itr_count = self.__class__.vof_correction_itr_count(service, version, mode, path + ["vof_correction_itr_count"])
                    self.volume_fraction_courant_number = self.__class__.volume_fraction_courant_number(service, version, mode, path + ["volume_fraction_courant_number"])
                    super().__init__(service, version, mode, path)
                class explicit_momentum_under_relaxation(TUIMethod):
                    """
                    .
                    """
                class explicit_pressure_under_relaxation(TUIMethod):
                    """
                    .
                    """
                class explicit_volume_fraction_under_relaxation(TUIMethod):
                    """
                    .
                    """
                class flow_courant_number(TUIMethod):
                    """
                    .
                    """
                class neighbor_correction_itr_count(TUIMethod):
                    """
                    .
                    """
                class skewness_correction_itr_count(TUIMethod):
                    """
                    .
                    """
                class skewness_neighbor_coupling(TUIMethod):
                    """
                    .
                    """
                class vof_correction_itr_count(TUIMethod):
                    """
                    .
                    """
                class volume_fraction_courant_number(TUIMethod):
                    """
                    .
                    """

            class pseudo_time_explicit_relaxation_factor(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.global_dt_pseudo_relax = self.__class__.global_dt_pseudo_relax(service, version, mode, path + ["global_dt_pseudo_relax"])
                    self.local_dt_dualts_relax = self.__class__.local_dt_dualts_relax(service, version, mode, path + ["local_dt_dualts_relax"])
                    super().__init__(service, version, mode, path)

                class global_dt_pseudo_relax(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit global-dt-pseudo-relax object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

                class local_dt_dualts_relax(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit local-dt-dualts-relax object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

            class pseudo_time_method_local_time_step(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.pseudo_time_courant_number = self.__class__.pseudo_time_courant_number(service, version, mode, path + ["pseudo_time_courant_number"])
                    self.pseudo_time_step_method_solid_zone = self.__class__.pseudo_time_step_method_solid_zone(service, version, mode, path + ["pseudo_time_step_method_solid_zone"])
                    self.time_step_size_scale_factor = self.__class__.time_step_size_scale_factor(service, version, mode, path + ["time_step_size_scale_factor"])
                    super().__init__(service, version, mode, path)
                class pseudo_time_courant_number(TUIMethod):
                    """
                    .
                    """
                class pseudo_time_step_method_solid_zone(TUIMethod):
                    """
                    .
                    """
                class time_step_size_scale_factor(TUIMethod):
                    """
                    .
                    """

            class relaxation_factor(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit relaxation-factor object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class under_relaxation(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit under-relaxation object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class zonal_pbns_solution_controls(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.amg_controls_scalar = self.__class__.amg_controls_scalar(service, version, mode, path + ["amg_controls_scalar"])
                    self.mg_controls = self.__class__.mg_controls(service, version, mode, path + ["mg_controls"])
                    self.auto_time_length_scale = self.__class__.auto_time_length_scale(service, version, mode, path + ["auto_time_length_scale"])
                    self.auto_time_length_scale_methods = self.__class__.auto_time_length_scale_methods(service, version, mode, path + ["auto_time_length_scale_methods"])
                    self.auto_time_step_size_scale_factor = self.__class__.auto_time_step_size_scale_factor(service, version, mode, path + ["auto_time_step_size_scale_factor"])
                    self.cpl_expl_relax_mom = self.__class__.cpl_expl_relax_mom(service, version, mode, path + ["cpl_expl_relax_mom"])
                    self.cpl_expl_relax_pressure = self.__class__.cpl_expl_relax_pressure(service, version, mode, path + ["cpl_expl_relax_pressure"])
                    self.cpl_pseudo_expl_relax_mom = self.__class__.cpl_pseudo_expl_relax_mom(service, version, mode, path + ["cpl_pseudo_expl_relax_mom"])
                    self.cpl_pseudo_expl_relax_pressure = self.__class__.cpl_pseudo_expl_relax_pressure(service, version, mode, path + ["cpl_pseudo_expl_relax_pressure"])
                    self.cpl_steady_expl_relax_mom = self.__class__.cpl_steady_expl_relax_mom(service, version, mode, path + ["cpl_steady_expl_relax_mom"])
                    self.cpl_steady_expl_relax_pressure = self.__class__.cpl_steady_expl_relax_pressure(service, version, mode, path + ["cpl_steady_expl_relax_pressure"])
                    self.dualts_explicit_mom = self.__class__.dualts_explicit_mom(service, version, mode, path + ["dualts_explicit_mom"])
                    self.dualts_explicit_pressure = self.__class__.dualts_explicit_pressure(service, version, mode, path + ["dualts_explicit_pressure"])
                    self.flow_courant_number = self.__class__.flow_courant_number(service, version, mode, path + ["flow_courant_number"])
                    self.fractstep_skewness_correction_itr = self.__class__.fractstep_skewness_correction_itr(service, version, mode, path + ["fractstep_skewness_correction_itr"])
                    self.global_dt_pseudo_time_step_size = self.__class__.global_dt_pseudo_time_step_size(service, version, mode, path + ["global_dt_pseudo_time_step_size"])
                    self.global_dt_time_step_method = self.__class__.global_dt_time_step_method(service, version, mode, path + ["global_dt_time_step_method"])
                    self.global_dt_verbosity = self.__class__.global_dt_verbosity(service, version, mode, path + ["global_dt_verbosity"])
                    self.local_dt_verbosity = self.__class__.local_dt_verbosity(service, version, mode, path + ["local_dt_verbosity"])
                    self.neighbor_correction_itr = self.__class__.neighbor_correction_itr(service, version, mode, path + ["neighbor_correction_itr"])
                    self.piso_skewness_correction_itr = self.__class__.piso_skewness_correction_itr(service, version, mode, path + ["piso_skewness_correction_itr"])
                    self.pseudo_time_localdt_courant_number = self.__class__.pseudo_time_localdt_courant_number(service, version, mode, path + ["pseudo_time_localdt_courant_number"])
                    self.simplec_skewness_correction_itr = self.__class__.simplec_skewness_correction_itr(service, version, mode, path + ["simplec_skewness_correction_itr"])
                    self.skewness_neighbor_coupling = self.__class__.skewness_neighbor_coupling(service, version, mode, path + ["skewness_neighbor_coupling"])
                    super().__init__(service, version, mode, path)
                class auto_time_length_scale(TUIMethod):
                    """
                    .
                    """
                class auto_time_length_scale_methods(TUIMethod):
                    """
                    .
                    """
                class auto_time_step_size_scale_factor(TUIMethod):
                    """
                    .
                    """
                class cpl_expl_relax_mom(TUIMethod):
                    """
                    .
                    """
                class cpl_expl_relax_pressure(TUIMethod):
                    """
                    .
                    """
                class cpl_pseudo_expl_relax_mom(TUIMethod):
                    """
                    .
                    """
                class cpl_pseudo_expl_relax_pressure(TUIMethod):
                    """
                    .
                    """
                class cpl_steady_expl_relax_mom(TUIMethod):
                    """
                    .
                    """
                class cpl_steady_expl_relax_pressure(TUIMethod):
                    """
                    .
                    """
                class dualts_explicit_mom(TUIMethod):
                    """
                    .
                    """
                class dualts_explicit_pressure(TUIMethod):
                    """
                    .
                    """
                class flow_courant_number(TUIMethod):
                    """
                    .
                    """
                class fractstep_skewness_correction_itr(TUIMethod):
                    """
                    .
                    """
                class global_dt_pseudo_time_step_size(TUIMethod):
                    """
                    .
                    """
                class global_dt_time_step_method(TUIMethod):
                    """
                    .
                    """
                class global_dt_verbosity(TUIMethod):
                    """
                    .
                    """
                class local_dt_verbosity(TUIMethod):
                    """
                    .
                    """
                class neighbor_correction_itr(TUIMethod):
                    """
                    .
                    """
                class piso_skewness_correction_itr(TUIMethod):
                    """
                    .
                    """
                class pseudo_time_localdt_courant_number(TUIMethod):
                    """
                    .
                    """
                class simplec_skewness_correction_itr(TUIMethod):
                    """
                    .
                    """
                class skewness_neighbor_coupling(TUIMethod):
                    """
                    .
                    """

                class amg_controls_scalar(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.coarsening_parameters = self.__class__.coarsening_parameters(service, version, mode, path + ["coarsening_parameters"])
                        self.fixed_cycle_parameters = self.__class__.fixed_cycle_parameters(service, version, mode, path + ["fixed_cycle_parameters"])
                        self.global_dt_smoother_type = self.__class__.global_dt_smoother_type(service, version, mode, path + ["global_dt_smoother_type"])
                        self.smoother_type = self.__class__.smoother_type(service, version, mode, path + ["smoother_type"])
                        super().__init__(service, version, mode, path)
                    class global_dt_smoother_type(TUIMethod):
                        """
                        .
                        """
                    class smoother_type(TUIMethod):
                        """
                        .
                        """

                    class coarsening_parameters(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.coarsen_by_interval = self.__class__.coarsen_by_interval(service, version, mode, path + ["coarsen_by_interval"])
                            self.global_dt_coarsen_by_interval = self.__class__.global_dt_coarsen_by_interval(service, version, mode, path + ["global_dt_coarsen_by_interval"])
                            super().__init__(service, version, mode, path)
                        class coarsen_by_interval(TUIMethod):
                            """
                            .
                            """
                        class global_dt_coarsen_by_interval(TUIMethod):
                            """
                            .
                            """

                    class fixed_cycle_parameters(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.global_dt_max_cycle = self.__class__.global_dt_max_cycle(service, version, mode, path + ["global_dt_max_cycle"])
                            self.global_dt_post_sweeps = self.__class__.global_dt_post_sweeps(service, version, mode, path + ["global_dt_post_sweeps"])
                            self.max_cycle = self.__class__.max_cycle(service, version, mode, path + ["max_cycle"])
                            self.post_sweeps = self.__class__.post_sweeps(service, version, mode, path + ["post_sweeps"])
                            super().__init__(service, version, mode, path)
                        class global_dt_max_cycle(TUIMethod):
                            """
                            .
                            """
                        class global_dt_post_sweeps(TUIMethod):
                            """
                            .
                            """
                        class max_cycle(TUIMethod):
                            """
                            .
                            """
                        class post_sweeps(TUIMethod):
                            """
                            .
                            """

                class mg_controls(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit mg-controls object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

        class initialization(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.defaults = self.__class__.defaults(service, version, mode, path + ["defaults"])
                self.fmg = self.__class__.fmg(service, version, mode, path + ["fmg"])
                self.hybrid_init_options = self.__class__.hybrid_init_options(service, version, mode, path + ["hybrid_init_options"])
                self.localized_turb_init = self.__class__.localized_turb_init(service, version, mode, path + ["localized_turb_init"])
                self.open_channel_auto_init = self.__class__.open_channel_auto_init(service, version, mode, path + ["open_channel_auto_init"])
                self.patch = self.__class__.patch(service, version, mode, path + ["patch"])
                self.compute_defaults = self.__class__.compute_defaults(service, version, mode, path + ["compute_defaults"])
                self.dpm_reset = self.__class__.dpm_reset(service, version, mode, path + ["dpm_reset"])
                self.enable_profile_memory_flushing = self.__class__.enable_profile_memory_flushing(service, version, mode, path + ["enable_profile_memory_flushing"])
                self.hybrid_initialize = self.__class__.hybrid_initialize(service, version, mode, path + ["hybrid_initialize"])
                self.init_acoustics_options = self.__class__.init_acoustics_options(service, version, mode, path + ["init_acoustics_options"])
                self.init_flow_statistics = self.__class__.init_flow_statistics(service, version, mode, path + ["init_flow_statistics"])
                self.init_lwf = self.__class__.init_lwf(service, version, mode, path + ["init_lwf"])
                self.init_turb_vel_fluctuations = self.__class__.init_turb_vel_fluctuations(service, version, mode, path + ["init_turb_vel_fluctuations"])
                self.initialization_type = self.__class__.initialization_type(service, version, mode, path + ["initialization_type"])
                self.initialize = self.__class__.initialize(service, version, mode, path + ["initialize"])
                self.levelset_auto_init = self.__class__.levelset_auto_init(service, version, mode, path + ["levelset_auto_init"])
                self.list_defaults = self.__class__.list_defaults(service, version, mode, path + ["list_defaults"])
                self.lwf_reset = self.__class__.lwf_reset(service, version, mode, path + ["lwf_reset"])
                self.reference_frame = self.__class__.reference_frame(service, version, mode, path + ["reference_frame"])
                self.show_iterations_sampled = self.__class__.show_iterations_sampled(service, version, mode, path + ["show_iterations_sampled"])
                self.show_time_sampled = self.__class__.show_time_sampled(service, version, mode, path + ["show_time_sampled"])
                self.standard_initialize = self.__class__.standard_initialize(service, version, mode, path + ["standard_initialize"])
                super().__init__(service, version, mode, path)
            class compute_defaults(TUIMethod):
                """
                .
                """
            class dpm_reset(TUIMethod):
                """
                .
                """
            class enable_profile_memory_flushing(TUIMethod):
                """
                .
                """
            class hybrid_initialize(TUIMethod):
                """
                .
                """
            class init_acoustics_options(TUIMethod):
                """
                .
                """
            class init_flow_statistics(TUIMethod):
                """
                .
                """
            class init_lwf(TUIMethod):
                """
                .
                """
            class init_turb_vel_fluctuations(TUIMethod):
                """
                .
                """
            class initialization_type(TUIMethod):
                """
                .
                """
            class initialize(TUIMethod):
                """
                .
                """
            class levelset_auto_init(TUIMethod):
                """
                .
                """
            class list_defaults(TUIMethod):
                """
                .
                """
            class lwf_reset(TUIMethod):
                """
                .
                """
            class reference_frame(TUIMethod):
                """
                .
                """
            class show_iterations_sampled(TUIMethod):
                """
                .
                """
            class show_time_sampled(TUIMethod):
                """
                .
                """
            class standard_initialize(TUIMethod):
                """
                .
                """

            class defaults(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit defaults object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class fmg(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.customize = self.__class__.customize(service, version, mode, path + ["customize"])
                    self.enable_fmg_verbose = self.__class__.enable_fmg_verbose(service, version, mode, path + ["enable_fmg_verbose"])
                    self.fmg_courant_number = self.__class__.fmg_courant_number(service, version, mode, path + ["fmg_courant_number"])
                    self.fmg_initialize = self.__class__.fmg_initialize(service, version, mode, path + ["fmg_initialize"])
                    self.reset_to_defaults = self.__class__.reset_to_defaults(service, version, mode, path + ["reset_to_defaults"])
                    self.species_reactions = self.__class__.species_reactions(service, version, mode, path + ["species_reactions"])
                    self.turbulent_viscosity_ratio = self.__class__.turbulent_viscosity_ratio(service, version, mode, path + ["turbulent_viscosity_ratio"])
                    self.viscous_terms = self.__class__.viscous_terms(service, version, mode, path + ["viscous_terms"])
                    super().__init__(service, version, mode, path)
                class customize(TUIMethod):
                    """
                    .
                    """
                class enable_fmg_verbose(TUIMethod):
                    """
                    .
                    """
                class fmg_courant_number(TUIMethod):
                    """
                    .
                    """
                class fmg_initialize(TUIMethod):
                    """
                    .
                    """
                class reset_to_defaults(TUIMethod):
                    """
                    .
                    """
                class species_reactions(TUIMethod):
                    """
                    .
                    """
                class turbulent_viscosity_ratio(TUIMethod):
                    """
                    .
                    """
                class viscous_terms(TUIMethod):
                    """
                    .
                    """

            class hybrid_init_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.general_settings = self.__class__.general_settings(service, version, mode, path + ["general_settings"])
                    self.species_setting = self.__class__.species_setting(service, version, mode, path + ["species_setting"])
                    self.turbulent_setting = self.__class__.turbulent_setting(service, version, mode, path + ["turbulent_setting"])
                    super().__init__(service, version, mode, path)

                class general_settings(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.initialization_options = self.__class__.initialization_options(service, version, mode, path + ["initialization_options"])
                        self.explicit_urf = self.__class__.explicit_urf(service, version, mode, path + ["explicit_urf"])
                        self.iter_count = self.__class__.iter_count(service, version, mode, path + ["iter_count"])
                        super().__init__(service, version, mode, path)
                    class explicit_urf(TUIMethod):
                        """
                        .
                        """
                    class iter_count(TUIMethod):
                        """
                        .
                        """

                    class initialization_options(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.const_velocity = self.__class__.const_velocity(service, version, mode, path + ["const_velocity"])
                            self.external_aero = self.__class__.external_aero(service, version, mode, path + ["external_aero"])
                            self.initial_pressure = self.__class__.initial_pressure(service, version, mode, path + ["initial_pressure"])
                            super().__init__(service, version, mode, path)
                        class const_velocity(TUIMethod):
                            """
                            .
                            """
                        class external_aero(TUIMethod):
                            """
                            .
                            """
                        class initial_pressure(TUIMethod):
                            """
                            .
                            """

                class species_setting(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.species = self.__class__.species(service, version, mode, path + ["species"])
                        self.user_specified_species = self.__class__.user_specified_species(service, version, mode, path + ["user_specified_species"])
                        super().__init__(service, version, mode, path)
                    class user_specified_species(TUIMethod):
                        """
                        .
                        """

                    class species(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.create = self.__class__.create(service, version, mode, path + ["create"])
                            self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                            self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                            self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                            self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                            super().__init__(service, version, mode, path)
                        class create(TUIMethod):
                            """
                            .
                            """
                        class delete(TUIMethod):
                            """
                            .
                            """
                        class edit(TUIMethod):
                            """
                            Edit species object.
                            """
                        class list(TUIMethod):
                            """
                            .
                            """
                        class list_properties(TUIMethod):
                            """
                            .
                            """
                        class make_a_copy(TUIMethod):
                            """
                            .
                            """
                        class rename(TUIMethod):
                            """
                            .
                            """

                class turbulent_setting(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.averaged_turbulent_parameters = self.__class__.averaged_turbulent_parameters(service, version, mode, path + ["averaged_turbulent_parameters"])
                        self.turbulent_intensity = self.__class__.turbulent_intensity(service, version, mode, path + ["turbulent_intensity"])
                        self.viscosity_ratio = self.__class__.viscosity_ratio(service, version, mode, path + ["viscosity_ratio"])
                        super().__init__(service, version, mode, path)
                    class averaged_turbulent_parameters(TUIMethod):
                        """
                        .
                        """
                    class turbulent_intensity(TUIMethod):
                        """
                        .
                        """
                    class viscosity_ratio(TUIMethod):
                        """
                        .
                        """

            class localized_turb_init(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                    self.turbulent_intensity = self.__class__.turbulent_intensity(service, version, mode, path + ["turbulent_intensity"])
                    self.turbulent_viscosity_ratio = self.__class__.turbulent_viscosity_ratio(service, version, mode, path + ["turbulent_viscosity_ratio"])
                    super().__init__(service, version, mode, path)
                class enabled(TUIMethod):
                    """
                    .
                    """
                class turbulent_intensity(TUIMethod):
                    """
                    .
                    """
                class turbulent_viscosity_ratio(TUIMethod):
                    """
                    .
                    """

            class open_channel_auto_init(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.boundary_zone = self.__class__.boundary_zone(service, version, mode, path + ["boundary_zone"])
                    self.flat_init = self.__class__.flat_init(service, version, mode, path + ["flat_init"])
                    self.wavy_surface_init = self.__class__.wavy_surface_init(service, version, mode, path + ["wavy_surface_init"])
                    super().__init__(service, version, mode, path)
                class boundary_zone(TUIMethod):
                    """
                    .
                    """
                class flat_init(TUIMethod):
                    """
                    .
                    """
                class wavy_surface_init(TUIMethod):
                    """
                    .
                    """

            class patch(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.vof_smooth_options = self.__class__.vof_smooth_options(service, version, mode, path + ["vof_smooth_options"])
                    self.calculate_patch = self.__class__.calculate_patch(service, version, mode, path + ["calculate_patch"])
                    super().__init__(service, version, mode, path)
                class calculate_patch(TUIMethod):
                    """
                    .
                    """

                class vof_smooth_options(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.execute_smoothing = self.__class__.execute_smoothing(service, version, mode, path + ["execute_smoothing"])
                        self.patch_reconstructed_interface = self.__class__.patch_reconstructed_interface(service, version, mode, path + ["patch_reconstructed_interface"])
                        self.smoothing_relaxation_factor = self.__class__.smoothing_relaxation_factor(service, version, mode, path + ["smoothing_relaxation_factor"])
                        self.use_volumetric_smoothing = self.__class__.use_volumetric_smoothing(service, version, mode, path + ["use_volumetric_smoothing"])
                        super().__init__(service, version, mode, path)
                    class execute_smoothing(TUIMethod):
                        """
                        .
                        """
                    class patch_reconstructed_interface(TUIMethod):
                        """
                        .
                        """
                    class smoothing_relaxation_factor(TUIMethod):
                        """
                        .
                        """
                    class use_volumetric_smoothing(TUIMethod):
                        """
                        .
                        """

        class methods(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.axisymmetric = self.__class__.axisymmetric(service, version, mode, path + ["axisymmetric"])
                self.convergence_acceleration_for_stretched_meshes = self.__class__.convergence_acceleration_for_stretched_meshes(service, version, mode, path + ["convergence_acceleration_for_stretched_meshes"])
                self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                self.flux_type = self.__class__.flux_type(service, version, mode, path + ["flux_type"])
                self.high_order_term_relaxation = self.__class__.high_order_term_relaxation(service, version, mode, path + ["high_order_term_relaxation"])
                self.high_speed_numerics = self.__class__.high_speed_numerics(service, version, mode, path + ["high_speed_numerics"])
                self.multiphase_numerics = self.__class__.multiphase_numerics(service, version, mode, path + ["multiphase_numerics"])
                self.nb_gradient_boundary_option = self.__class__.nb_gradient_boundary_option(service, version, mode, path + ["nb_gradient_boundary_option"])
                self.nita_expert_controls = self.__class__.nita_expert_controls(service, version, mode, path + ["nita_expert_controls"])
                self.overset = self.__class__.overset(service, version, mode, path + ["overset"])
                self.p_v_coupling = self.__class__.p_v_coupling(service, version, mode, path + ["p_v_coupling"])
                self.phase_based_vof_discretization = self.__class__.phase_based_vof_discretization(service, version, mode, path + ["phase_based_vof_discretization"])
                self.pseudo_time_method = self.__class__.pseudo_time_method(service, version, mode, path + ["pseudo_time_method"])
                self.reduced_rank_extrapolation_options = self.__class__.reduced_rank_extrapolation_options(service, version, mode, path + ["reduced_rank_extrapolation_options"])
                self.residual_smoothing = self.__class__.residual_smoothing(service, version, mode, path + ["residual_smoothing"])
                self.spatial_discretization = self.__class__.spatial_discretization(service, version, mode, path + ["spatial_discretization"])
                self.vof_numerics = self.__class__.vof_numerics(service, version, mode, path + ["vof_numerics"])
                self.warped_face_gradient_correction = self.__class__.warped_face_gradient_correction(service, version, mode, path + ["warped_face_gradient_correction"])
                self.accelerated_non_iterative_time_marching = self.__class__.accelerated_non_iterative_time_marching(service, version, mode, path + ["accelerated_non_iterative_time_marching"])
                self.bcd_boundedness = self.__class__.bcd_boundedness(service, version, mode, path + ["bcd_boundedness"])
                self.frozen_flux = self.__class__.frozen_flux(service, version, mode, path + ["frozen_flux"])
                self.nita = self.__class__.nita(service, version, mode, path + ["nita"])
                self.reduced_rank_extrapolation = self.__class__.reduced_rank_extrapolation(service, version, mode, path + ["reduced_rank_extrapolation"])
                self.set_solution_methods_to_default = self.__class__.set_solution_methods_to_default(service, version, mode, path + ["set_solution_methods_to_default"])
                self.species_disc_together = self.__class__.species_disc_together(service, version, mode, path + ["species_disc_together"])
                self.transient_formulation = self.__class__.transient_formulation(service, version, mode, path + ["transient_formulation"])
                self.unsteady_global_time = self.__class__.unsteady_global_time(service, version, mode, path + ["unsteady_global_time"])
                self.use_limiter_in_time = self.__class__.use_limiter_in_time(service, version, mode, path + ["use_limiter_in_time"])
                super().__init__(service, version, mode, path)
            class accelerated_non_iterative_time_marching(TUIMethod):
                """
                .
                """
            class bcd_boundedness(TUIMethod):
                """
                .
                """
            class frozen_flux(TUIMethod):
                """
                .
                """
            class nita(TUIMethod):
                """
                .
                """
            class reduced_rank_extrapolation(TUIMethod):
                """
                .
                """
            class set_solution_methods_to_default(TUIMethod):
                """
                .
                """
            class species_disc_together(TUIMethod):
                """
                .
                """
            class transient_formulation(TUIMethod):
                """
                .
                """
            class unsteady_global_time(TUIMethod):
                """
                .
                """
            class use_limiter_in_time(TUIMethod):
                """
                .
                """

            class axisymmetric(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axis_stabilization = self.__class__.axis_stabilization(service, version, mode, path + ["axis_stabilization"])
                    super().__init__(service, version, mode, path)
                class axis_stabilization(TUIMethod):
                    """
                    .
                    """

            class convergence_acceleration_for_stretched_meshes(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.casm_cutoff_multiplier = self.__class__.casm_cutoff_multiplier(service, version, mode, path + ["casm_cutoff_multiplier"])
                    self.convergence_acceleration_type = self.__class__.convergence_acceleration_type(service, version, mode, path + ["convergence_acceleration_type"])
                    super().__init__(service, version, mode, path)
                class casm_cutoff_multiplier(TUIMethod):
                    """
                    .
                    """
                class convergence_acceleration_type(TUIMethod):
                    """
                    .
                    """

            class expert(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.numerics_dbns = self.__class__.numerics_dbns(service, version, mode, path + ["numerics_dbns"])
                    self.numerics_pbns = self.__class__.numerics_pbns(service, version, mode, path + ["numerics_pbns"])
                    self.reaction_source_term_relaxation_factor = self.__class__.reaction_source_term_relaxation_factor(service, version, mode, path + ["reaction_source_term_relaxation_factor"])
                    self.reactions = self.__class__.reactions(service, version, mode, path + ["reactions"])
                    super().__init__(service, version, mode, path)
                class reaction_source_term_relaxation_factor(TUIMethod):
                    """
                    .
                    """
                class reactions(TUIMethod):
                    """
                    .
                    """

                class numerics_dbns(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.first_to_second_order_blending_dbns = self.__class__.first_to_second_order_blending_dbns(service, version, mode, path + ["first_to_second_order_blending_dbns"])
                        super().__init__(service, version, mode, path)
                    class first_to_second_order_blending_dbns(TUIMethod):
                        """
                        .
                        """

                class numerics_pbns(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.alternate_diffusion_for_porous_region_solids = self.__class__.alternate_diffusion_for_porous_region_solids(service, version, mode, path + ["alternate_diffusion_for_porous_region_solids"])
                        self.disable_rhie_chow_flux = self.__class__.disable_rhie_chow_flux(service, version, mode, path + ["disable_rhie_chow_flux"])
                        self.first_to_second_order_blending = self.__class__.first_to_second_order_blending(service, version, mode, path + ["first_to_second_order_blending"])
                        self.implicit_bodyforce_treatment = self.__class__.implicit_bodyforce_treatment(service, version, mode, path + ["implicit_bodyforce_treatment"])
                        self.physical_velocity_formulation = self.__class__.physical_velocity_formulation(service, version, mode, path + ["physical_velocity_formulation"])
                        self.presto_pressure_scheme = self.__class__.presto_pressure_scheme(service, version, mode, path + ["presto_pressure_scheme"])
                        self.velocity_formulation = self.__class__.velocity_formulation(service, version, mode, path + ["velocity_formulation"])
                        super().__init__(service, version, mode, path)
                    class alternate_diffusion_for_porous_region_solids(TUIMethod):
                        """
                        .
                        """
                    class disable_rhie_chow_flux(TUIMethod):
                        """
                        .
                        """
                    class first_to_second_order_blending(TUIMethod):
                        """
                        .
                        """
                    class implicit_bodyforce_treatment(TUIMethod):
                        """
                        .
                        """
                    class physical_velocity_formulation(TUIMethod):
                        """
                        .
                        """
                    class presto_pressure_scheme(TUIMethod):
                        """
                        .
                        """
                    class velocity_formulation(TUIMethod):
                        """
                        .
                        """

            class flux_type(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.dbns_cases = self.__class__.dbns_cases(service, version, mode, path + ["dbns_cases"])
                    self.pbns_cases = self.__class__.pbns_cases(service, version, mode, path + ["pbns_cases"])
                    super().__init__(service, version, mode, path)

                class dbns_cases(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.flux_type = self.__class__.flux_type(service, version, mode, path + ["flux_type"])
                        super().__init__(service, version, mode, path)
                    class flux_type(TUIMethod):
                        """
                        .
                        """

                class pbns_cases(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.flux_auto_select = self.__class__.flux_auto_select(service, version, mode, path + ["flux_auto_select"])
                        self.flux_type = self.__class__.flux_type(service, version, mode, path + ["flux_type"])
                        super().__init__(service, version, mode, path)
                    class flux_auto_select(TUIMethod):
                        """
                        .
                        """
                    class flux_type(TUIMethod):
                        """
                        .
                        """

            class high_order_term_relaxation(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.options = self.__class__.options(service, version, mode, path + ["options"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    .
                    """

                class options(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.relaxation_factor = self.__class__.relaxation_factor(service, version, mode, path + ["relaxation_factor"])
                        self.select_variables = self.__class__.select_variables(service, version, mode, path + ["select_variables"])
                        self.type = self.__class__.type(service, version, mode, path + ["type"])
                        super().__init__(service, version, mode, path)
                    class relaxation_factor(TUIMethod):
                        """
                        .
                        """
                    class select_variables(TUIMethod):
                        """
                        .
                        """
                    class type(TUIMethod):
                        """
                        .
                        """

            class high_speed_numerics(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.visualize_pressure_discontinuity_sensor = self.__class__.visualize_pressure_discontinuity_sensor(service, version, mode, path + ["visualize_pressure_discontinuity_sensor"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    .
                    """
                class expert(TUIMethod):
                    """
                    .
                    """
                class visualize_pressure_discontinuity_sensor(TUIMethod):
                    """
                    .
                    """

            class multiphase_numerics(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.advanced_stability_controls = self.__class__.advanced_stability_controls(service, version, mode, path + ["advanced_stability_controls"])
                    self.boiling_parameters = self.__class__.boiling_parameters(service, version, mode, path + ["boiling_parameters"])
                    self.compressible_flow = self.__class__.compressible_flow(service, version, mode, path + ["compressible_flow"])
                    self.default_controls = self.__class__.default_controls(service, version, mode, path + ["default_controls"])
                    self.energy = self.__class__.energy(service, version, mode, path + ["energy"])
                    self.face_pressure_controls = self.__class__.face_pressure_controls(service, version, mode, path + ["face_pressure_controls"])
                    self.heat_mass_transfer = self.__class__.heat_mass_transfer(service, version, mode, path + ["heat_mass_transfer"])
                    self.interphase_interactions = self.__class__.interphase_interactions(service, version, mode, path + ["interphase_interactions"])
                    self.porous_media = self.__class__.porous_media(service, version, mode, path + ["porous_media"])
                    self.solution_stabilization = self.__class__.solution_stabilization(service, version, mode, path + ["solution_stabilization"])
                    self.viscous_flow = self.__class__.viscous_flow(service, version, mode, path + ["viscous_flow"])
                    super().__init__(service, version, mode, path)

                class advanced_stability_controls(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.anti_diffusion = self.__class__.anti_diffusion(service, version, mode, path + ["anti_diffusion"])
                        self.equation_order = self.__class__.equation_order(service, version, mode, path + ["equation_order"])
                        self.hybrid_nita = self.__class__.hybrid_nita(service, version, mode, path + ["hybrid_nita"])
                        self.p_v_coupling = self.__class__.p_v_coupling(service, version, mode, path + ["p_v_coupling"])
                        self.pseudo_transient = self.__class__.pseudo_transient(service, version, mode, path + ["pseudo_transient"])
                        super().__init__(service, version, mode, path)

                    class anti_diffusion(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.enable_dynamic_strength = self.__class__.enable_dynamic_strength(service, version, mode, path + ["enable_dynamic_strength"])
                            self.set_dynamic_strength_exponent = self.__class__.set_dynamic_strength_exponent(service, version, mode, path + ["set_dynamic_strength_exponent"])
                            self.set_maximum_dynamic_strength = self.__class__.set_maximum_dynamic_strength(service, version, mode, path + ["set_maximum_dynamic_strength"])
                            super().__init__(service, version, mode, path)
                        class enable_dynamic_strength(TUIMethod):
                            """
                            .
                            """
                        class set_dynamic_strength_exponent(TUIMethod):
                            """
                            .
                            """
                        class set_maximum_dynamic_strength(TUIMethod):
                            """
                            .
                            """

                    class equation_order(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.solve_exp_vof_at_end = self.__class__.solve_exp_vof_at_end(service, version, mode, path + ["solve_exp_vof_at_end"])
                            self.solve_flow_last = self.__class__.solve_flow_last(service, version, mode, path + ["solve_flow_last"])
                            super().__init__(service, version, mode, path)
                        class solve_exp_vof_at_end(TUIMethod):
                            """
                            .
                            """
                        class solve_flow_last(TUIMethod):
                            """
                            .
                            """

                    class hybrid_nita(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.initial_outer_iterations = self.__class__.initial_outer_iterations(service, version, mode, path + ["initial_outer_iterations"])
                            self.instability_detector = self.__class__.instability_detector(service, version, mode, path + ["instability_detector"])
                            self.outer_iterations = self.__class__.outer_iterations(service, version, mode, path + ["outer_iterations"])
                            super().__init__(service, version, mode, path)
                        class outer_iterations(TUIMethod):
                            """
                            .
                            """

                        class initial_outer_iterations(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.initial_outer_iter = self.__class__.initial_outer_iter(service, version, mode, path + ["initial_outer_iter"])
                                self.initial_time_steps = self.__class__.initial_time_steps(service, version, mode, path + ["initial_time_steps"])
                                super().__init__(service, version, mode, path)
                            class initial_outer_iter(TUIMethod):
                                """
                                .
                                """
                            class initial_time_steps(TUIMethod):
                                """
                                .
                                """

                        class instability_detector(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.enable_instability_detector = self.__class__.enable_instability_detector(service, version, mode, path + ["enable_instability_detector"])
                                self.set_cfl_limit = self.__class__.set_cfl_limit(service, version, mode, path + ["set_cfl_limit"])
                                self.set_cfl_type = self.__class__.set_cfl_type(service, version, mode, path + ["set_cfl_type"])
                                self.set_velocity_limit = self.__class__.set_velocity_limit(service, version, mode, path + ["set_velocity_limit"])
                                self.unstable_event_outer_iterations = self.__class__.unstable_event_outer_iterations(service, version, mode, path + ["unstable_event_outer_iterations"])
                                super().__init__(service, version, mode, path)
                            class enable_instability_detector(TUIMethod):
                                """
                                .
                                """
                            class set_cfl_limit(TUIMethod):
                                """
                                .
                                """
                            class set_cfl_type(TUIMethod):
                                """
                                .
                                """
                            class set_velocity_limit(TUIMethod):
                                """
                                .
                                """
                            class unstable_event_outer_iterations(TUIMethod):
                                """
                                .
                                """

                    class p_v_coupling(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.coupled_vof = self.__class__.coupled_vof(service, version, mode, path + ["coupled_vof"])
                            self.rhie_chow_flux = self.__class__.rhie_chow_flux(service, version, mode, path + ["rhie_chow_flux"])
                            self.skewness_correction = self.__class__.skewness_correction(service, version, mode, path + ["skewness_correction"])
                            super().__init__(service, version, mode, path)

                        class coupled_vof(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.blended_treatment_for_buoyancy_forces = self.__class__.blended_treatment_for_buoyancy_forces(service, version, mode, path + ["blended_treatment_for_buoyancy_forces"])
                                self.buoyancy_force_linearization = self.__class__.buoyancy_force_linearization(service, version, mode, path + ["buoyancy_force_linearization"])
                                super().__init__(service, version, mode, path)
                            class blended_treatment_for_buoyancy_forces(TUIMethod):
                                """
                                .
                                """
                            class buoyancy_force_linearization(TUIMethod):
                                """
                                .
                                """

                        class rhie_chow_flux(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.low_order_rhie_chow = self.__class__.low_order_rhie_chow(service, version, mode, path + ["low_order_rhie_chow"])
                                super().__init__(service, version, mode, path)
                            class low_order_rhie_chow(TUIMethod):
                                """
                                .
                                """

                        class skewness_correction(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.limit_pressure_correction_gradient = self.__class__.limit_pressure_correction_gradient(service, version, mode, path + ["limit_pressure_correction_gradient"])
                                super().__init__(service, version, mode, path)
                            class limit_pressure_correction_gradient(TUIMethod):
                                """
                                .
                                """

                    class pseudo_transient(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.auto_dt_advanced_controls = self.__class__.auto_dt_advanced_controls(service, version, mode, path + ["auto_dt_advanced_controls"])
                            self.false_time_step_linearization = self.__class__.false_time_step_linearization(service, version, mode, path + ["false_time_step_linearization"])
                            self.num_of_density_smoothing = self.__class__.num_of_density_smoothing(service, version, mode, path + ["num_of_density_smoothing"])
                            self.smoothed_density_stabilization_method = self.__class__.smoothed_density_stabilization_method(service, version, mode, path + ["smoothed_density_stabilization_method"])
                            super().__init__(service, version, mode, path)
                        class false_time_step_linearization(TUIMethod):
                            """
                            .
                            """
                        class num_of_density_smoothing(TUIMethod):
                            """
                            .
                            """
                        class smoothed_density_stabilization_method(TUIMethod):
                            """
                            .
                            """

                        class auto_dt_advanced_controls(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.dt_factor_max = self.__class__.dt_factor_max(service, version, mode, path + ["dt_factor_max"])
                                self.dt_factor_min = self.__class__.dt_factor_min(service, version, mode, path + ["dt_factor_min"])
                                self.dt_init_limit = self.__class__.dt_init_limit(service, version, mode, path + ["dt_init_limit"])
                                self.dt_max = self.__class__.dt_max(service, version, mode, path + ["dt_max"])
                                self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                                self.max_velocity_ratio = self.__class__.max_velocity_ratio(service, version, mode, path + ["max_velocity_ratio"])
                                super().__init__(service, version, mode, path)
                            class dt_factor_max(TUIMethod):
                                """
                                .
                                """
                            class dt_factor_min(TUIMethod):
                                """
                                .
                                """
                            class dt_init_limit(TUIMethod):
                                """
                                .
                                """
                            class dt_max(TUIMethod):
                                """
                                .
                                """
                            class enable(TUIMethod):
                                """
                                .
                                """
                            class max_velocity_ratio(TUIMethod):
                                """
                                .
                                """

                class boiling_parameters(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.liquid_vof_factor = self.__class__.liquid_vof_factor(service, version, mode, path + ["liquid_vof_factor"])
                        self.thin_film = self.__class__.thin_film(service, version, mode, path + ["thin_film"])
                        super().__init__(service, version, mode, path)
                    class liquid_vof_factor(TUIMethod):
                        """
                        .
                        """
                    class thin_film(TUIMethod):
                        """
                        .
                        """

                class compressible_flow(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.alternate_bc_formulation = self.__class__.alternate_bc_formulation(service, version, mode, path + ["alternate_bc_formulation"])
                        self.analytical_thermodynamic_derivatives = self.__class__.analytical_thermodynamic_derivatives(service, version, mode, path + ["analytical_thermodynamic_derivatives"])
                        self.enhanced_numerics = self.__class__.enhanced_numerics(service, version, mode, path + ["enhanced_numerics"])
                        super().__init__(service, version, mode, path)
                    class alternate_bc_formulation(TUIMethod):
                        """
                        .
                        """
                    class analytical_thermodynamic_derivatives(TUIMethod):
                        """
                        .
                        """
                    class enhanced_numerics(TUIMethod):
                        """
                        .
                        """

                class default_controls(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.revert_to_pre_r20_1_default_settings = self.__class__.revert_to_pre_r20_1_default_settings(service, version, mode, path + ["revert_to_pre_r20_1_default_settings"])
                        self.recommended_defaults_for_existing_cases = self.__class__.recommended_defaults_for_existing_cases(service, version, mode, path + ["recommended_defaults_for_existing_cases"])
                        super().__init__(service, version, mode, path)
                    class recommended_defaults_for_existing_cases(TUIMethod):
                        """
                        .
                        """

                    class revert_to_pre_r20_1_default_settings(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.old_default_of_operating_density_method = self.__class__.old_default_of_operating_density_method(service, version, mode, path + ["old_default_of_operating_density_method"])
                            self.old_default_of_volume_fraction_smoothing = self.__class__.old_default_of_volume_fraction_smoothing(service, version, mode, path + ["old_default_of_volume_fraction_smoothing"])
                            self.old_variant_of_pesto_for_cases_using_structured_mesh = self.__class__.old_variant_of_pesto_for_cases_using_structured_mesh(service, version, mode, path + ["old_variant_of_pesto_for_cases_using_structured_mesh"])
                            super().__init__(service, version, mode, path)
                        class old_default_of_operating_density_method(TUIMethod):
                            """
                            .
                            """
                        class old_default_of_volume_fraction_smoothing(TUIMethod):
                            """
                            .
                            """
                        class old_variant_of_pesto_for_cases_using_structured_mesh(TUIMethod):
                            """
                            .
                            """

                class energy(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.phasic_wall_heat_flux_form = self.__class__.phasic_wall_heat_flux_form(service, version, mode, path + ["phasic_wall_heat_flux_form"])
                        super().__init__(service, version, mode, path)
                    class phasic_wall_heat_flux_form(TUIMethod):
                        """
                        .
                        """

                class face_pressure_controls(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.face_pressure_options = self.__class__.face_pressure_options(service, version, mode, path + ["face_pressure_options"])
                        super().__init__(service, version, mode, path)

                    class face_pressure_options(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.exclude_transient_term_in_face_pressure_calc = self.__class__.exclude_transient_term_in_face_pressure_calc(service, version, mode, path + ["exclude_transient_term_in_face_pressure_calc"])
                            self.face_pressure_calculation_method = self.__class__.face_pressure_calculation_method(service, version, mode, path + ["face_pressure_calculation_method"])
                            self.pressure_corr_grad = self.__class__.pressure_corr_grad(service, version, mode, path + ["pressure_corr_grad"])
                            super().__init__(service, version, mode, path)
                        class exclude_transient_term_in_face_pressure_calc(TUIMethod):
                            """
                            .
                            """
                        class face_pressure_calculation_method(TUIMethod):
                            """
                            .
                            """
                        class pressure_corr_grad(TUIMethod):
                            """
                            .
                            """

                class heat_mass_transfer(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.area_density = self.__class__.area_density(service, version, mode, path + ["area_density"])
                        self.boiling = self.__class__.boiling(service, version, mode, path + ["boiling"])
                        self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                        self.evaporation_condensation = self.__class__.evaporation_condensation(service, version, mode, path + ["evaporation_condensation"])
                        self.alternative_energy_treatment = self.__class__.alternative_energy_treatment(service, version, mode, path + ["alternative_energy_treatment"])
                        super().__init__(service, version, mode, path)
                    class alternative_energy_treatment(TUIMethod):
                        """
                        .
                        """

                    class area_density(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.ia_grad_sym = self.__class__.ia_grad_sym(service, version, mode, path + ["ia_grad_sym"])
                            self.vof_min_seeding = self.__class__.vof_min_seeding(service, version, mode, path + ["vof_min_seeding"])
                            super().__init__(service, version, mode, path)
                        class ia_grad_sym(TUIMethod):
                            """
                            .
                            """
                        class vof_min_seeding(TUIMethod):
                            """
                            .
                            """

                    class boiling(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.heat_flux_relaxation_factor = self.__class__.heat_flux_relaxation_factor(service, version, mode, path + ["heat_flux_relaxation_factor"])
                            self.show_expert_options = self.__class__.show_expert_options(service, version, mode, path + ["show_expert_options"])
                            self.two_resistance_boiling_framework = self.__class__.two_resistance_boiling_framework(service, version, mode, path + ["two_resistance_boiling_framework"])
                            super().__init__(service, version, mode, path)
                        class heat_flux_relaxation_factor(TUIMethod):
                            """
                            .
                            """
                        class show_expert_options(TUIMethod):
                            """
                            .
                            """
                        class two_resistance_boiling_framework(TUIMethod):
                            """
                            .
                            """

                    class cavitation(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.display_clipped_pressure = self.__class__.display_clipped_pressure(service, version, mode, path + ["display_clipped_pressure"])
                            self.max_vapor_pressure_ratio = self.__class__.max_vapor_pressure_ratio(service, version, mode, path + ["max_vapor_pressure_ratio"])
                            self.min_vapor_pressure = self.__class__.min_vapor_pressure(service, version, mode, path + ["min_vapor_pressure"])
                            self.old_treatment_for_turbulent_diffusion = self.__class__.old_treatment_for_turbulent_diffusion(service, version, mode, path + ["old_treatment_for_turbulent_diffusion"])
                            self.p_limit_method = self.__class__.p_limit_method(service, version, mode, path + ["p_limit_method"])
                            self.schnerr_cond_coeff = self.__class__.schnerr_cond_coeff(service, version, mode, path + ["schnerr_cond_coeff"])
                            self.schnerr_evap_coeff = self.__class__.schnerr_evap_coeff(service, version, mode, path + ["schnerr_evap_coeff"])
                            self.turbulent_diffusion = self.__class__.turbulent_diffusion(service, version, mode, path + ["turbulent_diffusion"])
                            super().__init__(service, version, mode, path)
                        class display_clipped_pressure(TUIMethod):
                            """
                            .
                            """
                        class max_vapor_pressure_ratio(TUIMethod):
                            """
                            .
                            """
                        class min_vapor_pressure(TUIMethod):
                            """
                            .
                            """
                        class old_treatment_for_turbulent_diffusion(TUIMethod):
                            """
                            .
                            """
                        class p_limit_method(TUIMethod):
                            """
                            .
                            """
                        class schnerr_cond_coeff(TUIMethod):
                            """
                            .
                            """
                        class schnerr_evap_coeff(TUIMethod):
                            """
                            .
                            """
                        class turbulent_diffusion(TUIMethod):
                            """
                            .
                            """

                    class evaporation_condensation(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.ia_norm_min_limit = self.__class__.ia_norm_min_limit(service, version, mode, path + ["ia_norm_min_limit"])
                            self.max_rel_humidity = self.__class__.max_rel_humidity(service, version, mode, path + ["max_rel_humidity"])
                            self.vof_from_max_limit = self.__class__.vof_from_max_limit(service, version, mode, path + ["vof_from_max_limit"])
                            self.vof_from_min_limit = self.__class__.vof_from_min_limit(service, version, mode, path + ["vof_from_min_limit"])
                            self.vof_to_max_limit = self.__class__.vof_to_max_limit(service, version, mode, path + ["vof_to_max_limit"])
                            self.vof_to_min_limit = self.__class__.vof_to_min_limit(service, version, mode, path + ["vof_to_min_limit"])
                            super().__init__(service, version, mode, path)
                        class ia_norm_min_limit(TUIMethod):
                            """
                            .
                            """
                        class max_rel_humidity(TUIMethod):
                            """
                            .
                            """
                        class vof_from_max_limit(TUIMethod):
                            """
                            .
                            """
                        class vof_from_min_limit(TUIMethod):
                            """
                            .
                            """
                        class vof_to_max_limit(TUIMethod):
                            """
                            .
                            """
                        class vof_to_min_limit(TUIMethod):
                            """
                            .
                            """

                class interphase_interactions(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.turbulence_interaction = self.__class__.turbulence_interaction(service, version, mode, path + ["turbulence_interaction"])
                        self.turbulent_dispersion = self.__class__.turbulent_dispersion(service, version, mode, path + ["turbulent_dispersion"])
                        super().__init__(service, version, mode, path)

                    class turbulence_interaction(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.turbulent_interaction_troshko_hassan = self.__class__.turbulent_interaction_troshko_hassan(service, version, mode, path + ["turbulent_interaction_troshko_hassan"])
                            super().__init__(service, version, mode, path)

                        class turbulent_interaction_troshko_hassan(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.t_h_freq_correction = self.__class__.t_h_freq_correction(service, version, mode, path + ["t_h_freq_correction"])
                                self.t_h_legacy = self.__class__.t_h_legacy(service, version, mode, path + ["t_h_legacy"])
                                self.t_h_vof_correction = self.__class__.t_h_vof_correction(service, version, mode, path + ["t_h_vof_correction"])
                                super().__init__(service, version, mode, path)
                            class t_h_freq_correction(TUIMethod):
                                """
                                .
                                """
                            class t_h_legacy(TUIMethod):
                                """
                                .
                                """
                            class t_h_vof_correction(TUIMethod):
                                """
                                .
                                """

                    class turbulent_dispersion(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.turbulent_dispersion_limit_vof = self.__class__.turbulent_dispersion_limit_vof(service, version, mode, path + ["turbulent_dispersion_limit_vof"])
                            self.turbulent_dispersion_trans_vof = self.__class__.turbulent_dispersion_trans_vof(service, version, mode, path + ["turbulent_dispersion_trans_vof"])
                            super().__init__(service, version, mode, path)

                        class turbulent_dispersion_limit_vof(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.create = self.__class__.create(service, version, mode, path + ["create"])
                                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                                self.list = self.__class__.list(service, version, mode, path + ["list"])
                                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                                super().__init__(service, version, mode, path)
                            class create(TUIMethod):
                                """
                                .
                                """
                            class delete(TUIMethod):
                                """
                                .
                                """
                            class edit(TUIMethod):
                                """
                                Edit turbulent-dispersion-limit-vof object.
                                """
                            class list(TUIMethod):
                                """
                                .
                                """
                            class list_properties(TUIMethod):
                                """
                                .
                                """
                            class make_a_copy(TUIMethod):
                                """
                                .
                                """
                            class rename(TUIMethod):
                                """
                                .
                                """

                        class turbulent_dispersion_trans_vof(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.turb_disp_trans_lower_vof = self.__class__.turb_disp_trans_lower_vof(service, version, mode, path + ["turb_disp_trans_lower_vof"])
                                self.turb_disp_trans_upper_vof = self.__class__.turb_disp_trans_upper_vof(service, version, mode, path + ["turb_disp_trans_upper_vof"])
                                super().__init__(service, version, mode, path)
                            class turb_disp_trans_lower_vof(TUIMethod):
                                """
                                .
                                """
                            class turb_disp_trans_upper_vof(TUIMethod):
                                """
                                .
                                """

                class porous_media(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.capillary_pressure_as_diffusion = self.__class__.capillary_pressure_as_diffusion(service, version, mode, path + ["capillary_pressure_as_diffusion"])
                        self.relative_permeability = self.__class__.relative_permeability(service, version, mode, path + ["relative_permeability"])
                        super().__init__(service, version, mode, path)
                    class capillary_pressure_as_diffusion(TUIMethod):
                        """
                        .
                        """
                    class relative_permeability(TUIMethod):
                        """
                        .
                        """

                class solution_stabilization(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.additional_stabilization_controls = self.__class__.additional_stabilization_controls(service, version, mode, path + ["additional_stabilization_controls"])
                        self.velocity_limiting_treatment = self.__class__.velocity_limiting_treatment(service, version, mode, path + ["velocity_limiting_treatment"])
                        self.execute_additional_stability_controls = self.__class__.execute_additional_stability_controls(service, version, mode, path + ["execute_additional_stability_controls"])
                        self.execute_advanced_stabilization = self.__class__.execute_advanced_stabilization(service, version, mode, path + ["execute_advanced_stabilization"])
                        self.execute_settings_optimization = self.__class__.execute_settings_optimization(service, version, mode, path + ["execute_settings_optimization"])
                        super().__init__(service, version, mode, path)
                    class execute_additional_stability_controls(TUIMethod):
                        """
                        .
                        """
                    class execute_advanced_stabilization(TUIMethod):
                        """
                        .
                        """
                    class execute_settings_optimization(TUIMethod):
                        """
                        .
                        """

                    class additional_stabilization_controls(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.blended_compressive_scheme = self.__class__.blended_compressive_scheme(service, version, mode, path + ["blended_compressive_scheme"])
                            self.pseudo_time_stabilization = self.__class__.pseudo_time_stabilization(service, version, mode, path + ["pseudo_time_stabilization"])
                            super().__init__(service, version, mode, path)
                        class blended_compressive_scheme(TUIMethod):
                            """
                            .
                            """
                        class pseudo_time_stabilization(TUIMethod):
                            """
                            .
                            """

                    class velocity_limiting_treatment(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.set_damping_strengths = self.__class__.set_damping_strengths(service, version, mode, path + ["set_damping_strengths"])
                            self.set_velocity_and_vof_cutoffs = self.__class__.set_velocity_and_vof_cutoffs(service, version, mode, path + ["set_velocity_and_vof_cutoffs"])
                            self.enable_velocity_limiting = self.__class__.enable_velocity_limiting(service, version, mode, path + ["enable_velocity_limiting"])
                            self.set_damping_strength = self.__class__.set_damping_strength(service, version, mode, path + ["set_damping_strength"])
                            self.set_velocity_cutoff = self.__class__.set_velocity_cutoff(service, version, mode, path + ["set_velocity_cutoff"])
                            self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                            super().__init__(service, version, mode, path)
                        class enable_velocity_limiting(TUIMethod):
                            """
                            .
                            """
                        class set_damping_strength(TUIMethod):
                            """
                            .
                            """
                        class set_velocity_cutoff(TUIMethod):
                            """
                            .
                            """
                        class verbosity(TUIMethod):
                            """
                            .
                            """

                        class set_damping_strengths(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.create = self.__class__.create(service, version, mode, path + ["create"])
                                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                                self.list = self.__class__.list(service, version, mode, path + ["list"])
                                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                                super().__init__(service, version, mode, path)
                            class create(TUIMethod):
                                """
                                .
                                """
                            class delete(TUIMethod):
                                """
                                .
                                """
                            class edit(TUIMethod):
                                """
                                Edit set-damping-strengths object.
                                """
                            class list(TUIMethod):
                                """
                                .
                                """
                            class list_properties(TUIMethod):
                                """
                                .
                                """
                            class make_a_copy(TUIMethod):
                                """
                                .
                                """
                            class rename(TUIMethod):
                                """
                                .
                                """

                        class set_velocity_and_vof_cutoffs(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.create = self.__class__.create(service, version, mode, path + ["create"])
                                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                                self.list = self.__class__.list(service, version, mode, path + ["list"])
                                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                                super().__init__(service, version, mode, path)
                            class create(TUIMethod):
                                """
                                .
                                """
                            class delete(TUIMethod):
                                """
                                .
                                """
                            class edit(TUIMethod):
                                """
                                Edit set-velocity-and-vof-cutoffs object.
                                """
                            class list(TUIMethod):
                                """
                                .
                                """
                            class list_properties(TUIMethod):
                                """
                                .
                                """
                            class make_a_copy(TUIMethod):
                                """
                                .
                                """
                            class rename(TUIMethod):
                                """
                                .
                                """

                class viscous_flow(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.interfacial_artificial_viscosity = self.__class__.interfacial_artificial_viscosity(service, version, mode, path + ["interfacial_artificial_viscosity"])
                        self.density_func_expo = self.__class__.density_func_expo(service, version, mode, path + ["density_func_expo"])
                        self.density_ratio_cutoff = self.__class__.density_ratio_cutoff(service, version, mode, path + ["density_ratio_cutoff"])
                        self.turb_visc_based_damping = self.__class__.turb_visc_based_damping(service, version, mode, path + ["turb_visc_based_damping"])
                        self.viscosity_averaging = self.__class__.viscosity_averaging(service, version, mode, path + ["viscosity_averaging"])
                        super().__init__(service, version, mode, path)
                    class density_func_expo(TUIMethod):
                        """
                        .
                        """
                    class density_ratio_cutoff(TUIMethod):
                        """
                        .
                        """
                    class turb_visc_based_damping(TUIMethod):
                        """
                        .
                        """
                    class viscosity_averaging(TUIMethod):
                        """
                        .
                        """

                    class interfacial_artificial_viscosity(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.boundry_treatment = self.__class__.boundry_treatment(service, version, mode, path + ["boundry_treatment"])
                            self.density_func_options = self.__class__.density_func_options(service, version, mode, path + ["density_func_options"])
                            self.exponent_density_func = self.__class__.exponent_density_func(service, version, mode, path + ["exponent_density_func"])
                            self.exponent_smoothing_func = self.__class__.exponent_smoothing_func(service, version, mode, path + ["exponent_smoothing_func"])
                            self.n_smooth_for_interfacial_regims = self.__class__.n_smooth_for_interfacial_regims(service, version, mode, path + ["n_smooth_for_interfacial_regims"])
                            self.near_wall_treatment = self.__class__.near_wall_treatment(service, version, mode, path + ["near_wall_treatment"])
                            self.sm_relax_factor = self.__class__.sm_relax_factor(service, version, mode, path + ["sm_relax_factor"])
                            self.viscous_func_options = self.__class__.viscous_func_options(service, version, mode, path + ["viscous_func_options"])
                            super().__init__(service, version, mode, path)
                        class boundry_treatment(TUIMethod):
                            """
                            .
                            """
                        class density_func_options(TUIMethod):
                            """
                            .
                            """
                        class exponent_density_func(TUIMethod):
                            """
                            .
                            """
                        class exponent_smoothing_func(TUIMethod):
                            """
                            .
                            """
                        class n_smooth_for_interfacial_regims(TUIMethod):
                            """
                            .
                            """
                        class near_wall_treatment(TUIMethod):
                            """
                            .
                            """
                        class sm_relax_factor(TUIMethod):
                            """
                            .
                            """
                        class viscous_func_options(TUIMethod):
                            """
                            .
                            """

            class nb_gradient_boundary_option(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.nb_gradient = self.__class__.nb_gradient(service, version, mode, path + ["nb_gradient"])
                    self.nb_gradient_dbns = self.__class__.nb_gradient_dbns(service, version, mode, path + ["nb_gradient_dbns"])
                    super().__init__(service, version, mode, path)
                class nb_gradient(TUIMethod):
                    """
                    .
                    """
                class nb_gradient_dbns(TUIMethod):
                    """
                    .
                    """

            class nita_expert_controls(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.hybrid_nita_settings = self.__class__.hybrid_nita_settings(service, version, mode, path + ["hybrid_nita_settings"])
                    self.skewness_neighbor_coupling = self.__class__.skewness_neighbor_coupling(service, version, mode, path + ["skewness_neighbor_coupling"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class skewness_neighbor_coupling(TUIMethod):
                    """
                    .
                    """
                class verbosity(TUIMethod):
                    """
                    .
                    """

                class hybrid_nita_settings(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.multi_phase_setting = self.__class__.multi_phase_setting(service, version, mode, path + ["multi_phase_setting"])
                        self.single_phase_setting = self.__class__.single_phase_setting(service, version, mode, path + ["single_phase_setting"])
                        super().__init__(service, version, mode, path)
                    class single_phase_setting(TUIMethod):
                        """
                        .
                        """

                    class multi_phase_setting(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                            self.options = self.__class__.options(service, version, mode, path + ["options"])
                            super().__init__(service, version, mode, path)
                        class enable(TUIMethod):
                            """
                            .
                            """
                        class options(TUIMethod):
                            """
                            .
                            """

            class overset(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.high_order_pressure = self.__class__.high_order_pressure(service, version, mode, path + ["high_order_pressure"])
                    self.interpolation_method = self.__class__.interpolation_method(service, version, mode, path + ["interpolation_method"])
                    self.orphan_cell_treatment = self.__class__.orphan_cell_treatment(service, version, mode, path + ["orphan_cell_treatment"])
                    super().__init__(service, version, mode, path)
                class high_order_pressure(TUIMethod):
                    """
                    .
                    """
                class interpolation_method(TUIMethod):
                    """
                    .
                    """
                class orphan_cell_treatment(TUIMethod):
                    """
                    .
                    """

                class expert(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.hybrid_mode_selection = self.__class__.hybrid_mode_selection(service, version, mode, path + ["hybrid_mode_selection"])
                        self.mass_flux_correction_method = self.__class__.mass_flux_correction_method(service, version, mode, path + ["mass_flux_correction_method"])
                        super().__init__(service, version, mode, path)
                    class hybrid_mode_selection(TUIMethod):
                        """
                        .
                        """
                    class mass_flux_correction_method(TUIMethod):
                        """
                        .
                        """

            class p_v_coupling(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.coupled_form = self.__class__.coupled_form(service, version, mode, path + ["coupled_form"])
                    self.flow_scheme = self.__class__.flow_scheme(service, version, mode, path + ["flow_scheme"])
                    self.neighbor_correction_itr_count = self.__class__.neighbor_correction_itr_count(service, version, mode, path + ["neighbor_correction_itr_count"])
                    self.skewness_correction_itr_count = self.__class__.skewness_correction_itr_count(service, version, mode, path + ["skewness_correction_itr_count"])
                    self.skewness_neighbor_coupling = self.__class__.skewness_neighbor_coupling(service, version, mode, path + ["skewness_neighbor_coupling"])
                    self.solve_n_phase = self.__class__.solve_n_phase(service, version, mode, path + ["solve_n_phase"])
                    super().__init__(service, version, mode, path)
                class coupled_form(TUIMethod):
                    """
                    .
                    """
                class flow_scheme(TUIMethod):
                    """
                    .
                    """
                class neighbor_correction_itr_count(TUIMethod):
                    """
                    .
                    """
                class skewness_correction_itr_count(TUIMethod):
                    """
                    .
                    """
                class skewness_neighbor_coupling(TUIMethod):
                    """
                    .
                    """
                class solve_n_phase(TUIMethod):
                    """
                    .
                    """

            class phase_based_vof_discretization(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit phase-based-vof-discretization object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class pseudo_time_method(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.convergence_acceleration_for_stretched_meshes = self.__class__.convergence_acceleration_for_stretched_meshes(service, version, mode, path + ["convergence_acceleration_for_stretched_meshes"])
                    self.formulation = self.__class__.formulation(service, version, mode, path + ["formulation"])
                    self.relaxation_bounds = self.__class__.relaxation_bounds(service, version, mode, path + ["relaxation_bounds"])
                    self.relaxation_method = self.__class__.relaxation_method(service, version, mode, path + ["relaxation_method"])
                    super().__init__(service, version, mode, path)
                class relaxation_bounds(TUIMethod):
                    """
                    .
                    """
                class relaxation_method(TUIMethod):
                    """
                    .
                    """

                class convergence_acceleration_for_stretched_meshes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.casm_cutoff_multiplier = self.__class__.casm_cutoff_multiplier(service, version, mode, path + ["casm_cutoff_multiplier"])
                        self.convergence_acceleration_type = self.__class__.convergence_acceleration_type(service, version, mode, path + ["convergence_acceleration_type"])
                        super().__init__(service, version, mode, path)
                    class casm_cutoff_multiplier(TUIMethod):
                        """
                        .
                        """
                    class convergence_acceleration_type(TUIMethod):
                        """
                        .
                        """

                class formulation(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.coupled_solver = self.__class__.coupled_solver(service, version, mode, path + ["coupled_solver"])
                        self.density_based_solver = self.__class__.density_based_solver(service, version, mode, path + ["density_based_solver"])
                        self.segregated_solver = self.__class__.segregated_solver(service, version, mode, path + ["segregated_solver"])
                        super().__init__(service, version, mode, path)
                    class coupled_solver(TUIMethod):
                        """
                        .
                        """
                    class density_based_solver(TUIMethod):
                        """
                        .
                        """
                    class segregated_solver(TUIMethod):
                        """
                        .
                        """

            class reduced_rank_extrapolation_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.skip_iter_count = self.__class__.skip_iter_count(service, version, mode, path + ["skip_iter_count"])
                    self.subspace_size = self.__class__.subspace_size(service, version, mode, path + ["subspace_size"])
                    super().__init__(service, version, mode, path)
                class skip_iter_count(TUIMethod):
                    """
                    .
                    """
                class subspace_size(TUIMethod):
                    """
                    .
                    """

            class residual_smoothing(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.residual_smoothing_factor = self.__class__.residual_smoothing_factor(service, version, mode, path + ["residual_smoothing_factor"])
                    self.residual_smoothing_iter_count = self.__class__.residual_smoothing_iter_count(service, version, mode, path + ["residual_smoothing_iter_count"])
                    super().__init__(service, version, mode, path)
                class residual_smoothing_factor(TUIMethod):
                    """
                    .
                    """
                class residual_smoothing_iter_count(TUIMethod):
                    """
                    .
                    """

            class spatial_discretization(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.discretization_scheme = self.__class__.discretization_scheme(service, version, mode, path + ["discretization_scheme"])
                    self.gradient_scheme = self.__class__.gradient_scheme(service, version, mode, path + ["gradient_scheme"])
                    super().__init__(service, version, mode, path)
                class gradient_scheme(TUIMethod):
                    """
                    .
                    """

                class discretization_scheme(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit discretization-scheme object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

            class vof_numerics(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.force_treatment_of_unsteady_rc = self.__class__.force_treatment_of_unsteady_rc(service, version, mode, path + ["force_treatment_of_unsteady_rc"])
                    self.high_order_rc = self.__class__.high_order_rc(service, version, mode, path + ["high_order_rc"])
                    self.high_order_rc_hybrid_treatment = self.__class__.high_order_rc_hybrid_treatment(service, version, mode, path + ["high_order_rc_hybrid_treatment"])
                    self.new_framework_for_vof_specific_node_based_treatment = self.__class__.new_framework_for_vof_specific_node_based_treatment(service, version, mode, path + ["new_framework_for_vof_specific_node_based_treatment"])
                    self.unstructured_var_presto_scheme = self.__class__.unstructured_var_presto_scheme(service, version, mode, path + ["unstructured_var_presto_scheme"])
                    super().__init__(service, version, mode, path)
                class force_treatment_of_unsteady_rc(TUIMethod):
                    """
                    .
                    """
                class high_order_rc(TUIMethod):
                    """
                    .
                    """
                class high_order_rc_hybrid_treatment(TUIMethod):
                    """
                    .
                    """
                class new_framework_for_vof_specific_node_based_treatment(TUIMethod):
                    """
                    .
                    """
                class unstructured_var_presto_scheme(TUIMethod):
                    """
                    .
                    """

            class warped_face_gradient_correction(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.mode = self.__class__.mode(service, version, mode, path + ["mode"])
                    self.turbulence_options = self.__class__.turbulence_options(service, version, mode, path + ["turbulence_options"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    .
                    """
                class mode(TUIMethod):
                    """
                    .
                    """
                class turbulence_options(TUIMethod):
                    """
                    .
                    """

        class monitor(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.convergence_conditions = self.__class__.convergence_conditions(service, version, mode, path + ["convergence_conditions"])
                self.report_files = self.__class__.report_files(service, version, mode, path + ["report_files"])
                self.report_plots = self.__class__.report_plots(service, version, mode, path + ["report_plots"])
                self.residual = self.__class__.residual(service, version, mode, path + ["residual"])
                super().__init__(service, version, mode, path)

            class convergence_conditions(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.convergence_reports = self.__class__.convergence_reports(service, version, mode, path + ["convergence_reports"])
                    self.check_for = self.__class__.check_for(service, version, mode, path + ["check_for"])
                    self.condition = self.__class__.condition(service, version, mode, path + ["condition"])
                    self.frequency = self.__class__.frequency(service, version, mode, path + ["frequency"])
                    super().__init__(service, version, mode, path)
                class check_for(TUIMethod):
                    """
                    .
                    """
                class condition(TUIMethod):
                    """
                    .
                    """
                class frequency(TUIMethod):
                    """
                    .
                    """

                class convergence_reports(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit convergence-reports object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

            class report_files(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.clear_data = self.__class__.clear_data(service, version, mode, path + ["clear_data"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class clear_data(TUIMethod):
                    """
                    .
                    """
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class delete_all(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit report-files object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class report_plots(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class delete_all(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit report-plots object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class residual(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                    self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                    self.equations = self.__class__.equations(service, version, mode, path + ["equations"])
                    self.options = self.__class__.options(service, version, mode, path + ["options"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    self.renormalize = self.__class__.renormalize(service, version, mode, path + ["renormalize"])
                    self.reset = self.__class__.reset(service, version, mode, path + ["reset"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    super().__init__(service, version, mode, path)
                class plot(TUIMethod):
                    """
                    .
                    """
                class renormalize(TUIMethod):
                    """
                    .
                    """
                class reset(TUIMethod):
                    """
                    .
                    """
                class write(TUIMethod):
                    """
                    .
                    """

                class axes(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.x = self.__class__.x(service, version, mode, path + ["x"])
                        self.y = self.__class__.y(service, version, mode, path + ["y"])
                        self.background_color = self.__class__.background_color(service, version, mode, path + ["background_color"])
                        super().__init__(service, version, mode, path)
                    class background_color(TUIMethod):
                        """
                        .
                        """

                    class x(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                    class y(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.major_gridlines = self.__class__.major_gridlines(service, version, mode, path + ["major_gridlines"])
                            self.minor_gridlines = self.__class__.minor_gridlines(service, version, mode, path + ["minor_gridlines"])
                            self.number_format = self.__class__.number_format(service, version, mode, path + ["number_format"])
                            self.auto_range = self.__class__.auto_range(service, version, mode, path + ["auto_range"])
                            self.label = self.__class__.label(service, version, mode, path + ["label"])
                            self.log_scale = self.__class__.log_scale(service, version, mode, path + ["log_scale"])
                            self.max = self.__class__.max(service, version, mode, path + ["max"])
                            self.min = self.__class__.min(service, version, mode, path + ["min"])
                            self.show_major_gridlines = self.__class__.show_major_gridlines(service, version, mode, path + ["show_major_gridlines"])
                            self.show_minor_gridlines = self.__class__.show_minor_gridlines(service, version, mode, path + ["show_minor_gridlines"])
                            super().__init__(service, version, mode, path)
                        class auto_range(TUIMethod):
                            """
                            .
                            """
                        class label(TUIMethod):
                            """
                            .
                            """
                        class log_scale(TUIMethod):
                            """
                            .
                            """
                        class max(TUIMethod):
                            """
                            .
                            """
                        class min(TUIMethod):
                            """
                            .
                            """
                        class show_major_gridlines(TUIMethod):
                            """
                            .
                            """
                        class show_minor_gridlines(TUIMethod):
                            """
                            .
                            """

                        class major_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class minor_gridlines(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.color = self.__class__.color(service, version, mode, path + ["color"])
                                self.weight = self.__class__.weight(service, version, mode, path + ["weight"])
                                super().__init__(service, version, mode, path)
                            class color(TUIMethod):
                                """
                                .
                                """
                            class weight(TUIMethod):
                                """
                                .
                                """

                        class number_format(TUIMenu):
                            """
                            .
                            """
                            def __init__(self, service, version, mode, path):
                                self.format_type = self.__class__.format_type(service, version, mode, path + ["format_type"])
                                self.precision = self.__class__.precision(service, version, mode, path + ["precision"])
                                super().__init__(service, version, mode, path)
                            class format_type(TUIMethod):
                                """
                                .
                                """
                            class precision(TUIMethod):
                                """
                                .
                                """

                class curves(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.resize = self.__class__.resize(service, version, mode, path + ["resize"])
                        super().__init__(service, version, mode, path)
                    class edit(TUIMethod):
                        """
                        Edit curves object.
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class resize(TUIMethod):
                        """
                        .
                        """

                class equations(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit equations object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

                class options(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.residual_values = self.__class__.residual_values(service, version, mode, path + ["residual_values"])
                        self.criterion_type = self.__class__.criterion_type(service, version, mode, path + ["criterion_type"])
                        self.enhanced_continuity_residual = self.__class__.enhanced_continuity_residual(service, version, mode, path + ["enhanced_continuity_residual"])
                        self.n_display = self.__class__.n_display(service, version, mode, path + ["n_display"])
                        self.n_maximize_norms = self.__class__.n_maximize_norms(service, version, mode, path + ["n_maximize_norms"])
                        self.n_save = self.__class__.n_save(service, version, mode, path + ["n_save"])
                        self.normalize = self.__class__.normalize(service, version, mode, path + ["normalize"])
                        self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                        self.print = self.__class__.print(service, version, mode, path + ["print"])
                        super().__init__(service, version, mode, path)
                    class criterion_type(TUIMethod):
                        """
                        .
                        """
                    class enhanced_continuity_residual(TUIMethod):
                        """
                        .
                        """
                    class n_display(TUIMethod):
                        """
                        .
                        """
                    class n_maximize_norms(TUIMethod):
                        """
                        .
                        """
                    class n_save(TUIMethod):
                        """
                        .
                        """
                    class normalize(TUIMethod):
                        """
                        .
                        """
                    class plot(TUIMethod):
                        """
                        .
                        """
                    class print(TUIMethod):
                        """
                        .
                        """

                    class residual_values(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.compute_local_scale = self.__class__.compute_local_scale(service, version, mode, path + ["compute_local_scale"])
                            self.reporting_option = self.__class__.reporting_option(service, version, mode, path + ["reporting_option"])
                            self.scale_residuals = self.__class__.scale_residuals(service, version, mode, path + ["scale_residuals"])
                            super().__init__(service, version, mode, path)
                        class compute_local_scale(TUIMethod):
                            """
                            .
                            """
                        class reporting_option(TUIMethod):
                            """
                            .
                            """
                        class scale_residuals(TUIMethod):
                            """
                            .
                            """

        class report_definitions(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.aeromechanics = self.__class__.aeromechanics(service, version, mode, path + ["aeromechanics"])
                self.custom = self.__class__.custom(service, version, mode, path + ["custom"])
                self.drag = self.__class__.drag(service, version, mode, path + ["drag"])
                self.expression = self.__class__.expression(service, version, mode, path + ["expression"])
                self.flux = self.__class__.flux(service, version, mode, path + ["flux"])
                self.force = self.__class__.force(service, version, mode, path + ["force"])
                self.icing = self.__class__.icing(service, version, mode, path + ["icing"])
                self.injection = self.__class__.injection(service, version, mode, path + ["injection"])
                self.lift = self.__class__.lift(service, version, mode, path + ["lift"])
                self.mesh = self.__class__.mesh(service, version, mode, path + ["mesh"])
                self.moment = self.__class__.moment(service, version, mode, path + ["moment"])
                self.single_valued_expression = self.__class__.single_valued_expression(service, version, mode, path + ["single_valued_expression"])
                self.surface = self.__class__.surface(service, version, mode, path + ["surface"])
                self.time = self.__class__.time(service, version, mode, path + ["time"])
                self.user_defined = self.__class__.user_defined(service, version, mode, path + ["user_defined"])
                self.vbm = self.__class__.vbm(service, version, mode, path + ["vbm"])
                self.volume = self.__class__.volume(service, version, mode, path + ["volume"])
                self.compute = self.__class__.compute(service, version, mode, path + ["compute"])
                self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                super().__init__(service, version, mode, path)
            class compute(TUIMethod):
                """
                .
                """
            class copy(TUIMethod):
                """
                .
                """
            class delete_all(TUIMethod):
                """
                .
                """

            class aeromechanics(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit aeromechanics object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class custom(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit custom object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class drag(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit drag object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class expression(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit expression object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class flux(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit flux object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class force(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit force object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class icing(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit icing object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class injection(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit injection object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class lift(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit lift object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class mesh(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit mesh object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class moment(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit moment object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class single_valued_expression(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit single-valued-expression object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class surface(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit surface object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class time(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit time object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class user_defined(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit user-defined object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class vbm(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit vbm object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

            class volume(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                    self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                    self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                    super().__init__(service, version, mode, path)
                class create(TUIMethod):
                    """
                    .
                    """
                class delete(TUIMethod):
                    """
                    .
                    """
                class edit(TUIMethod):
                    """
                    Edit volume object.
                    """
                class list(TUIMethod):
                    """
                    .
                    """
                class list_properties(TUIMethod):
                    """
                    .
                    """
                class make_a_copy(TUIMethod):
                    """
                    .
                    """
                class rename(TUIMethod):
                    """
                    .
                    """

        class run_calculation(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.adaptive_time_stepping = self.__class__.adaptive_time_stepping(service, version, mode, path + ["adaptive_time_stepping"])
                self.cfl_based_adaptive_time_stepping = self.__class__.cfl_based_adaptive_time_stepping(service, version, mode, path + ["cfl_based_adaptive_time_stepping"])
                self.data_sampling = self.__class__.data_sampling(service, version, mode, path + ["data_sampling"])
                self.data_sampling_options = self.__class__.data_sampling_options(service, version, mode, path + ["data_sampling_options"])
                self.pollutants = self.__class__.pollutants(service, version, mode, path + ["pollutants"])
                self.pseudo_time_settings = self.__class__.pseudo_time_settings(service, version, mode, path + ["pseudo_time_settings"])
                self.transient_controls = self.__class__.transient_controls(service, version, mode, path + ["transient_controls"])
                self.calculate = self.__class__.calculate(service, version, mode, path + ["calculate"])
                self.dual_time_iterate = self.__class__.dual_time_iterate(service, version, mode, path + ["dual_time_iterate"])
                self.interrupt = self.__class__.interrupt(service, version, mode, path + ["interrupt"])
                self.iter_count = self.__class__.iter_count(service, version, mode, path + ["iter_count"])
                self.iterate = self.__class__.iterate(service, version, mode, path + ["iterate"])
                self.profile_update_interval = self.__class__.profile_update_interval(service, version, mode, path + ["profile_update_interval"])
                self.reporting_interval = self.__class__.reporting_interval(service, version, mode, path + ["reporting_interval"])
                self.residual_verbosity = self.__class__.residual_verbosity(service, version, mode, path + ["residual_verbosity"])
                self.time_step_count = self.__class__.time_step_count(service, version, mode, path + ["time_step_count"])
                super().__init__(service, version, mode, path)
            class calculate(TUIMethod):
                """
                .
                """
            class dual_time_iterate(TUIMethod):
                """
                .
                """
            class interrupt(TUIMethod):
                """
                .
                """
            class iter_count(TUIMethod):
                """
                .
                """
            class iterate(TUIMethod):
                """
                .
                """
            class profile_update_interval(TUIMethod):
                """
                .
                """
            class reporting_interval(TUIMethod):
                """
                .
                """
            class residual_verbosity(TUIMethod):
                """
                .
                """
            class time_step_count(TUIMethod):
                """
                .
                """

            class adaptive_time_stepping(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                    self.error_tolerance = self.__class__.error_tolerance(service, version, mode, path + ["error_tolerance"])
                    self.fixed_time_step_count = self.__class__.fixed_time_step_count(service, version, mode, path + ["fixed_time_step_count"])
                    self.max_step_change_factor = self.__class__.max_step_change_factor(service, version, mode, path + ["max_step_change_factor"])
                    self.max_time_step = self.__class__.max_time_step(service, version, mode, path + ["max_time_step"])
                    self.min_step_change_factor = self.__class__.min_step_change_factor(service, version, mode, path + ["min_step_change_factor"])
                    self.min_time_step = self.__class__.min_time_step(service, version, mode, path + ["min_time_step"])
                    self.time_end = self.__class__.time_end(service, version, mode, path + ["time_end"])
                    self.user_defined_timestep = self.__class__.user_defined_timestep(service, version, mode, path + ["user_defined_timestep"])
                    super().__init__(service, version, mode, path)
                class enabled(TUIMethod):
                    """
                    .
                    """
                class error_tolerance(TUIMethod):
                    """
                    .
                    """
                class fixed_time_step_count(TUIMethod):
                    """
                    .
                    """
                class max_step_change_factor(TUIMethod):
                    """
                    .
                    """
                class max_time_step(TUIMethod):
                    """
                    .
                    """
                class min_step_change_factor(TUIMethod):
                    """
                    .
                    """
                class min_time_step(TUIMethod):
                    """
                    .
                    """
                class time_end(TUIMethod):
                    """
                    .
                    """
                class user_defined_timestep(TUIMethod):
                    """
                    .
                    """

            class cfl_based_adaptive_time_stepping(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.desired_cfl = self.__class__.desired_cfl(service, version, mode, path + ["desired_cfl"])
                    self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                    self.initial_time_step = self.__class__.initial_time_step(service, version, mode, path + ["initial_time_step"])
                    self.max_fixed_time_step = self.__class__.max_fixed_time_step(service, version, mode, path + ["max_fixed_time_step"])
                    self.max_step_change_factor = self.__class__.max_step_change_factor(service, version, mode, path + ["max_step_change_factor"])
                    self.max_time_step = self.__class__.max_time_step(service, version, mode, path + ["max_time_step"])
                    self.min_step_change_factor = self.__class__.min_step_change_factor(service, version, mode, path + ["min_step_change_factor"])
                    self.min_time_step = self.__class__.min_time_step(service, version, mode, path + ["min_time_step"])
                    self.time_end = self.__class__.time_end(service, version, mode, path + ["time_end"])
                    self.update_interval_time_step_size = self.__class__.update_interval_time_step_size(service, version, mode, path + ["update_interval_time_step_size"])
                    self.user_defined_timestep = self.__class__.user_defined_timestep(service, version, mode, path + ["user_defined_timestep"])
                    super().__init__(service, version, mode, path)
                class desired_cfl(TUIMethod):
                    """
                    .
                    """
                class enabled(TUIMethod):
                    """
                    .
                    """
                class initial_time_step(TUIMethod):
                    """
                    .
                    """
                class max_fixed_time_step(TUIMethod):
                    """
                    .
                    """
                class max_step_change_factor(TUIMethod):
                    """
                    .
                    """
                class max_time_step(TUIMethod):
                    """
                    .
                    """
                class min_step_change_factor(TUIMethod):
                    """
                    .
                    """
                class min_time_step(TUIMethod):
                    """
                    .
                    """
                class time_end(TUIMethod):
                    """
                    .
                    """
                class update_interval_time_step_size(TUIMethod):
                    """
                    .
                    """
                class user_defined_timestep(TUIMethod):
                    """
                    .
                    """

            class data_sampling(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.custom_field_functions = self.__class__.custom_field_functions(service, version, mode, path + ["custom_field_functions"])
                    self.dpm_variables = self.__class__.dpm_variables(service, version, mode, path + ["dpm_variables"])
                    self.enable_custom_field_functions = self.__class__.enable_custom_field_functions(service, version, mode, path + ["enable_custom_field_functions"])
                    self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                    self.flow_heat_fluxes = self.__class__.flow_heat_fluxes(service, version, mode, path + ["flow_heat_fluxes"])
                    self.flow_shear_stresses = self.__class__.flow_shear_stresses(service, version, mode, path + ["flow_shear_stresses"])
                    self.force_statistics = self.__class__.force_statistics(service, version, mode, path + ["force_statistics"])
                    self.sampling_interval = self.__class__.sampling_interval(service, version, mode, path + ["sampling_interval"])
                    self.species_list = self.__class__.species_list(service, version, mode, path + ["species_list"])
                    self.statistics_mixture_fraction = self.__class__.statistics_mixture_fraction(service, version, mode, path + ["statistics_mixture_fraction"])
                    self.statistics_reaction_progress = self.__class__.statistics_reaction_progress(service, version, mode, path + ["statistics_reaction_progress"])
                    self.time_sampled = self.__class__.time_sampled(service, version, mode, path + ["time_sampled"])
                    self.wall_statistics = self.__class__.wall_statistics(service, version, mode, path + ["wall_statistics"])
                    super().__init__(service, version, mode, path)
                class custom_field_functions(TUIMethod):
                    """
                    .
                    """
                class dpm_variables(TUIMethod):
                    """
                    .
                    """
                class enable_custom_field_functions(TUIMethod):
                    """
                    .
                    """
                class enabled(TUIMethod):
                    """
                    .
                    """
                class flow_heat_fluxes(TUIMethod):
                    """
                    .
                    """
                class flow_shear_stresses(TUIMethod):
                    """
                    .
                    """
                class force_statistics(TUIMethod):
                    """
                    .
                    """
                class sampling_interval(TUIMethod):
                    """
                    .
                    """
                class species_list(TUIMethod):
                    """
                    .
                    """
                class statistics_mixture_fraction(TUIMethod):
                    """
                    .
                    """
                class statistics_reaction_progress(TUIMethod):
                    """
                    .
                    """
                class time_sampled(TUIMethod):
                    """
                    .
                    """
                class wall_statistics(TUIMethod):
                    """
                    .
                    """

            class data_sampling_options(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.data_sets = self.__class__.data_sets(service, version, mode, path + ["data_sets"])
                    self.add_datasets = self.__class__.add_datasets(service, version, mode, path + ["add_datasets"])
                    self.list_datasets = self.__class__.list_datasets(service, version, mode, path + ["list_datasets"])
                    super().__init__(service, version, mode, path)
                class add_datasets(TUIMethod):
                    """
                    .
                    """
                class list_datasets(TUIMethod):
                    """
                    .
                    """

                class data_sets(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit data-sets object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

            class pollutants(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.num_of_post_iter_per_timestep = self.__class__.num_of_post_iter_per_timestep(service, version, mode, path + ["num_of_post_iter_per_timestep"])
                    self.postprocess = self.__class__.postprocess(service, version, mode, path + ["postprocess"])
                    super().__init__(service, version, mode, path)
                class num_of_post_iter_per_timestep(TUIMethod):
                    """
                    .
                    """
                class postprocess(TUIMethod):
                    """
                    .
                    """

            class pseudo_time_settings(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.time_step_method = self.__class__.time_step_method(service, version, mode, path + ["time_step_method"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class verbosity(TUIMethod):
                    """
                    .
                    """

                class time_step_method(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.auto_time_size_calc_solid_zone = self.__class__.auto_time_size_calc_solid_zone(service, version, mode, path + ["auto_time_size_calc_solid_zone"])
                        self.length_scale = self.__class__.length_scale(service, version, mode, path + ["length_scale"])
                        self.length_scale_methods = self.__class__.length_scale_methods(service, version, mode, path + ["length_scale_methods"])
                        self.pseudo_time_step_size = self.__class__.pseudo_time_step_size(service, version, mode, path + ["pseudo_time_step_size"])
                        self.time_solid_scale_factor = self.__class__.time_solid_scale_factor(service, version, mode, path + ["time_solid_scale_factor"])
                        self.time_step_method = self.__class__.time_step_method(service, version, mode, path + ["time_step_method"])
                        self.time_step_size_for_solid_zone = self.__class__.time_step_size_for_solid_zone(service, version, mode, path + ["time_step_size_for_solid_zone"])
                        self.time_step_size_scale_factor = self.__class__.time_step_size_scale_factor(service, version, mode, path + ["time_step_size_scale_factor"])
                        super().__init__(service, version, mode, path)
                    class auto_time_size_calc_solid_zone(TUIMethod):
                        """
                        .
                        """
                    class length_scale(TUIMethod):
                        """
                        .
                        """
                    class length_scale_methods(TUIMethod):
                        """
                        .
                        """
                    class pseudo_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class time_solid_scale_factor(TUIMethod):
                        """
                        .
                        """
                    class time_step_method(TUIMethod):
                        """
                        .
                        """
                    class time_step_size_for_solid_zone(TUIMethod):
                        """
                        .
                        """
                    class time_step_size_scale_factor(TUIMethod):
                        """
                        .
                        """

            class transient_controls(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.cfl_based_time_stepping = self.__class__.cfl_based_time_stepping(service, version, mode, path + ["cfl_based_time_stepping"])
                    self.cfl_based_time_stepping_advanced_options = self.__class__.cfl_based_time_stepping_advanced_options(service, version, mode, path + ["cfl_based_time_stepping_advanced_options"])
                    self.error_based_time_stepping = self.__class__.error_based_time_stepping(service, version, mode, path + ["error_based_time_stepping"])
                    self.extrapolate_eqn_vars = self.__class__.extrapolate_eqn_vars(service, version, mode, path + ["extrapolate_eqn_vars"])
                    self.fixed_periodic = self.__class__.fixed_periodic(service, version, mode, path + ["fixed_periodic"])
                    self.mp_specific_time_stepping = self.__class__.mp_specific_time_stepping(service, version, mode, path + ["mp_specific_time_stepping"])
                    self.multiphase_specific_time_constraints = self.__class__.multiphase_specific_time_constraints(service, version, mode, path + ["multiphase_specific_time_constraints"])
                    self.solid_time_step_size = self.__class__.solid_time_step_size(service, version, mode, path + ["solid_time_step_size"])
                    self.duration_specification_method = self.__class__.duration_specification_method(service, version, mode, path + ["duration_specification_method"])
                    self.extrapolate_variables = self.__class__.extrapolate_variables(service, version, mode, path + ["extrapolate_variables"])
                    self.incremental_time = self.__class__.incremental_time(service, version, mode, path + ["incremental_time"])
                    self.max_flow_time = self.__class__.max_flow_time(service, version, mode, path + ["max_flow_time"])
                    self.max_iter_per_time_step = self.__class__.max_iter_per_time_step(service, version, mode, path + ["max_iter_per_time_step"])
                    self.method = self.__class__.method(service, version, mode, path + ["method"])
                    self.predict_next = self.__class__.predict_next(service, version, mode, path + ["predict_next"])
                    self.rotating_mesh_flow_predictor = self.__class__.rotating_mesh_flow_predictor(service, version, mode, path + ["rotating_mesh_flow_predictor"])
                    self.solution_status = self.__class__.solution_status(service, version, mode, path + ["solution_status"])
                    self.specified_time_step = self.__class__.specified_time_step(service, version, mode, path + ["specified_time_step"])
                    self.time_step_count = self.__class__.time_step_count(service, version, mode, path + ["time_step_count"])
                    self.time_step_size = self.__class__.time_step_size(service, version, mode, path + ["time_step_size"])
                    self.time_step_size_for_acoustic_export = self.__class__.time_step_size_for_acoustic_export(service, version, mode, path + ["time_step_size_for_acoustic_export"])
                    self.total_time = self.__class__.total_time(service, version, mode, path + ["total_time"])
                    self.total_time_step_count = self.__class__.total_time_step_count(service, version, mode, path + ["total_time_step_count"])
                    self.type = self.__class__.type(service, version, mode, path + ["type"])
                    self.udf_hook = self.__class__.udf_hook(service, version, mode, path + ["udf_hook"])
                    self.undo_timestep = self.__class__.undo_timestep(service, version, mode, path + ["undo_timestep"])
                    super().__init__(service, version, mode, path)
                class duration_specification_method(TUIMethod):
                    """
                    .
                    """
                class extrapolate_variables(TUIMethod):
                    """
                    .
                    """
                class incremental_time(TUIMethod):
                    """
                    .
                    """
                class max_flow_time(TUIMethod):
                    """
                    .
                    """
                class max_iter_per_time_step(TUIMethod):
                    """
                    .
                    """
                class method(TUIMethod):
                    """
                    .
                    """
                class predict_next(TUIMethod):
                    """
                    .
                    """
                class rotating_mesh_flow_predictor(TUIMethod):
                    """
                    .
                    """
                class solution_status(TUIMethod):
                    """
                    .
                    """
                class specified_time_step(TUIMethod):
                    """
                    .
                    """
                class time_step_count(TUIMethod):
                    """
                    .
                    """
                class time_step_size(TUIMethod):
                    """
                    .
                    """
                class time_step_size_for_acoustic_export(TUIMethod):
                    """
                    .
                    """
                class total_time(TUIMethod):
                    """
                    .
                    """
                class total_time_step_count(TUIMethod):
                    """
                    .
                    """
                class type(TUIMethod):
                    """
                    .
                    """
                class udf_hook(TUIMethod):
                    """
                    .
                    """
                class undo_timestep(TUIMethod):
                    """
                    .
                    """

                class cfl_based_time_stepping(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.courant_number = self.__class__.courant_number(service, version, mode, path + ["courant_number"])
                        self.fixed_time_step_size = self.__class__.fixed_time_step_size(service, version, mode, path + ["fixed_time_step_size"])
                        self.initial_time_step_size = self.__class__.initial_time_step_size(service, version, mode, path + ["initial_time_step_size"])
                        self.max_step_change_factor = self.__class__.max_step_change_factor(service, version, mode, path + ["max_step_change_factor"])
                        self.max_time_step_size = self.__class__.max_time_step_size(service, version, mode, path + ["max_time_step_size"])
                        self.min_step_change_factor = self.__class__.min_step_change_factor(service, version, mode, path + ["min_step_change_factor"])
                        self.min_time_step_size = self.__class__.min_time_step_size(service, version, mode, path + ["min_time_step_size"])
                        self.update_interval = self.__class__.update_interval(service, version, mode, path + ["update_interval"])
                        super().__init__(service, version, mode, path)
                    class courant_number(TUIMethod):
                        """
                        .
                        """
                    class fixed_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class initial_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class max_step_change_factor(TUIMethod):
                        """
                        .
                        """
                    class max_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class min_step_change_factor(TUIMethod):
                        """
                        .
                        """
                    class min_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class update_interval(TUIMethod):
                        """
                        .
                        """

                class cfl_based_time_stepping_advanced_options(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.cfl_type = self.__class__.cfl_type(service, version, mode, path + ["cfl_type"])
                        self.control_time_step_size_variation = self.__class__.control_time_step_size_variation(service, version, mode, path + ["control_time_step_size_variation"])
                        self.use_average_cfl = self.__class__.use_average_cfl(service, version, mode, path + ["use_average_cfl"])
                        super().__init__(service, version, mode, path)
                    class cfl_type(TUIMethod):
                        """
                        .
                        """
                    class control_time_step_size_variation(TUIMethod):
                        """
                        .
                        """
                    class use_average_cfl(TUIMethod):
                        """
                        .
                        """

                class error_based_time_stepping(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.error_tolerance = self.__class__.error_tolerance(service, version, mode, path + ["error_tolerance"])
                        self.fixed_time_step_size = self.__class__.fixed_time_step_size(service, version, mode, path + ["fixed_time_step_size"])
                        self.initial_time_step_size = self.__class__.initial_time_step_size(service, version, mode, path + ["initial_time_step_size"])
                        self.max_step_change_factor = self.__class__.max_step_change_factor(service, version, mode, path + ["max_step_change_factor"])
                        self.max_time_step_size = self.__class__.max_time_step_size(service, version, mode, path + ["max_time_step_size"])
                        self.min_step_change_factor = self.__class__.min_step_change_factor(service, version, mode, path + ["min_step_change_factor"])
                        self.min_time_step_size = self.__class__.min_time_step_size(service, version, mode, path + ["min_time_step_size"])
                        self.update_interval = self.__class__.update_interval(service, version, mode, path + ["update_interval"])
                        super().__init__(service, version, mode, path)
                    class error_tolerance(TUIMethod):
                        """
                        .
                        """
                    class fixed_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class initial_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class max_step_change_factor(TUIMethod):
                        """
                        .
                        """
                    class max_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class min_step_change_factor(TUIMethod):
                        """
                        .
                        """
                    class min_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class update_interval(TUIMethod):
                        """
                        .
                        """

                class extrapolate_eqn_vars(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit extrapolate-eqn-vars object.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """

                class fixed_periodic(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                        self.fixed_periodic_type = self.__class__.fixed_periodic_type(service, version, mode, path + ["fixed_periodic_type"])
                        self.frequency = self.__class__.frequency(service, version, mode, path + ["frequency"])
                        self.period = self.__class__.period(service, version, mode, path + ["period"])
                        self.time_step_size = self.__class__.time_step_size(service, version, mode, path + ["time_step_size"])
                        self.time_step_size_count = self.__class__.time_step_size_count(service, version, mode, path + ["time_step_size_count"])
                        self.time_steps_per_period = self.__class__.time_steps_per_period(service, version, mode, path + ["time_steps_per_period"])
                        self.total_periods = self.__class__.total_periods(service, version, mode, path + ["total_periods"])
                        super().__init__(service, version, mode, path)
                    class enabled(TUIMethod):
                        """
                        .
                        """
                    class fixed_periodic_type(TUIMethod):
                        """
                        .
                        """
                    class frequency(TUIMethod):
                        """
                        .
                        """
                    class period(TUIMethod):
                        """
                        .
                        """
                    class time_step_size(TUIMethod):
                        """
                        .
                        """
                    class time_step_size_count(TUIMethod):
                        """
                        .
                        """
                    class time_steps_per_period(TUIMethod):
                        """
                        .
                        """
                    class total_periods(TUIMethod):
                        """
                        .
                        """

                class mp_specific_time_stepping(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.enabled = self.__class__.enabled(service, version, mode, path + ["enabled"])
                        self.fixed_time_step_size = self.__class__.fixed_time_step_size(service, version, mode, path + ["fixed_time_step_size"])
                        self.global_courant_number = self.__class__.global_courant_number(service, version, mode, path + ["global_courant_number"])
                        self.initial_time_step_size = self.__class__.initial_time_step_size(service, version, mode, path + ["initial_time_step_size"])
                        self.max_step_change_factor = self.__class__.max_step_change_factor(service, version, mode, path + ["max_step_change_factor"])
                        self.max_time_step_size = self.__class__.max_time_step_size(service, version, mode, path + ["max_time_step_size"])
                        self.min_step_change_factor = self.__class__.min_step_change_factor(service, version, mode, path + ["min_step_change_factor"])
                        self.min_time_step_size = self.__class__.min_time_step_size(service, version, mode, path + ["min_time_step_size"])
                        self.update_interval = self.__class__.update_interval(service, version, mode, path + ["update_interval"])
                        super().__init__(service, version, mode, path)
                    class enabled(TUIMethod):
                        """
                        .
                        """
                    class fixed_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class global_courant_number(TUIMethod):
                        """
                        .
                        """
                    class initial_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class max_step_change_factor(TUIMethod):
                        """
                        .
                        """
                    class max_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class min_step_change_factor(TUIMethod):
                        """
                        .
                        """
                    class min_time_step_size(TUIMethod):
                        """
                        .
                        """
                    class update_interval(TUIMethod):
                        """
                        .
                        """

                class multiphase_specific_time_constraints(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.moving_mesh_cfl_constraint = self.__class__.moving_mesh_cfl_constraint(service, version, mode, path + ["moving_mesh_cfl_constraint"])
                        self.time_scale_options = self.__class__.time_scale_options(service, version, mode, path + ["time_scale_options"])
                        self.physics_based_constraint = self.__class__.physics_based_constraint(service, version, mode, path + ["physics_based_constraint"])
                        self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                        super().__init__(service, version, mode, path)
                    class physics_based_constraint(TUIMethod):
                        """
                        .
                        """
                    class verbosity(TUIMethod):
                        """
                        .
                        """

                    class moving_mesh_cfl_constraint(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.mesh_courant_number = self.__class__.mesh_courant_number(service, version, mode, path + ["mesh_courant_number"])
                            self.moving_mesh_constraint = self.__class__.moving_mesh_constraint(service, version, mode, path + ["moving_mesh_constraint"])
                            super().__init__(service, version, mode, path)
                        class mesh_courant_number(TUIMethod):
                            """
                            .
                            """
                        class moving_mesh_constraint(TUIMethod):
                            """
                            .
                            """

                    class time_scale_options(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.acoustic_scale = self.__class__.acoustic_scale(service, version, mode, path + ["acoustic_scale"])
                            self.gravity_scale = self.__class__.gravity_scale(service, version, mode, path + ["gravity_scale"])
                            self.surface_tension_scale = self.__class__.surface_tension_scale(service, version, mode, path + ["surface_tension_scale"])
                            self.viscous_scale = self.__class__.viscous_scale(service, version, mode, path + ["viscous_scale"])
                            super().__init__(service, version, mode, path)
                        class acoustic_scale(TUIMethod):
                            """
                            .
                            """
                        class gravity_scale(TUIMethod):
                            """
                            .
                            """
                        class surface_tension_scale(TUIMethod):
                            """
                            .
                            """
                        class viscous_scale(TUIMethod):
                            """
                            .
                            """

                class solid_time_step_size(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.choose_auto_time_stepping = self.__class__.choose_auto_time_stepping(service, version, mode, path + ["choose_auto_time_stepping"])
                        self.enable_solid_time_step = self.__class__.enable_solid_time_step(service, version, mode, path + ["enable_solid_time_step"])
                        self.time_step_size = self.__class__.time_step_size(service, version, mode, path + ["time_step_size"])
                        super().__init__(service, version, mode, path)
                    class choose_auto_time_stepping(TUIMethod):
                        """
                        .
                        """
                    class enable_solid_time_step(TUIMethod):
                        """
                        .
                        """
                    class time_step_size(TUIMethod):
                        """
                        .
                        """

    class solve(TUIMenu):
        """
        Enter the solve menu.
        """
        def __init__(self, service, version, mode, path):
            self.animate = self.__class__.animate(service, version, mode, path + ["animate"])
            self.cell_register_operations = self.__class__.cell_register_operations(service, version, mode, path + ["cell_register_operations"])
            self.cell_registers = self.__class__.cell_registers(service, version, mode, path + ["cell_registers"])
            self.execute_commands = self.__class__.execute_commands(service, version, mode, path + ["execute_commands"])
            self.initialize = self.__class__.initialize(service, version, mode, path + ["initialize"])
            self.monitors = self.__class__.monitors(service, version, mode, path + ["monitors"])
            self.report_definitions = self.__class__.report_definitions(service, version, mode, path + ["report_definitions"])
            self.report_files = self.__class__.report_files(service, version, mode, path + ["report_files"])
            self.report_plots = self.__class__.report_plots(service, version, mode, path + ["report_plots"])
            self.set = self.__class__.set(service, version, mode, path + ["set"])
            self.convergence_conditions = self.__class__.convergence_conditions(service, version, mode, path + ["convergence_conditions"])
            self.dpm_update = self.__class__.dpm_update(service, version, mode, path + ["dpm_update"])
            self.dual_time_iterate = self.__class__.dual_time_iterate(service, version, mode, path + ["dual_time_iterate"])
            self.iterate = self.__class__.iterate(service, version, mode, path + ["iterate"])
            self.iterate_steady_2way_fsi = self.__class__.iterate_steady_2way_fsi(service, version, mode, path + ["iterate_steady_2way_fsi"])
            self.max_iterations_per_time_step = self.__class__.max_iterations_per_time_step(service, version, mode, path + ["max_iterations_per_time_step"])
            self.mesh_motion = self.__class__.mesh_motion(service, version, mode, path + ["mesh_motion"])
            self.multistage_time_iterate = self.__class__.multistage_time_iterate(service, version, mode, path + ["multistage_time_iterate"])
            self.patch = self.__class__.patch(service, version, mode, path + ["patch"])
            self.update_physical_time = self.__class__.update_physical_time(service, version, mode, path + ["update_physical_time"])
            super().__init__(service, version, mode, path)
        class convergence_conditions(TUIMethod):
            """
            Manage convergence report.
            """
        class dpm_update(TUIMethod):
            """
            Update discrete phase source terms.
            """
        class dual_time_iterate(TUIMethod):
            """
            .
            """
        class iterate(TUIMethod):
            """
            .
            """
        class iterate_steady_2way_fsi(TUIMethod):
            """
            Perform a specified number of steps.
            """
        class max_iterations_per_time_step(TUIMethod):
            """
            Set maximum iterations per time step for transient case.
            """
        class mesh_motion(TUIMethod):
            """
            Perform mesh motion.
            """
        class multistage_time_iterate(TUIMethod):
            """
            Perform unsteady iterations.
            """
        class patch(TUIMethod):
            """
            Patch a value for a flow variable in the domain.
            """
        class update_physical_time(TUIMethod):
            """
            Update the solution to the next physical time level.
            """

        class animate(TUIMenu):
            """
            Enter the animation menu.
            """
            def __init__(self, service, version, mode, path):
                self.define = self.__class__.define(service, version, mode, path + ["define"])
                self.inverse_dft = self.__class__.inverse_dft(service, version, mode, path + ["inverse_dft"])
                self.keyframe_animation = self.__class__.keyframe_animation(service, version, mode, path + ["keyframe_animation"])
                self.objects = self.__class__.objects(service, version, mode, path + ["objects"])
                self.playback = self.__class__.playback(service, version, mode, path + ["playback"])
                self.pulse = self.__class__.pulse(service, version, mode, path + ["pulse"])
                super().__init__(service, version, mode, path)

            class define(TUIMenu):
                """
                Enter the animation definition menu.
                """
                def __init__(self, service, version, mode, path):
                    self.define_monitor = self.__class__.define_monitor(service, version, mode, path + ["define_monitor"])
                    self.edit_monitor = self.__class__.edit_monitor(service, version, mode, path + ["edit_monitor"])
                    super().__init__(service, version, mode, path)
                class define_monitor(TUIMethod):
                    """
                    Define new animation.
                    """
                class edit_monitor(TUIMethod):
                    """
                    Change animation monitor attributes.
                    """

            class inverse_dft(TUIMenu):
                """
                Reconstruct DFT signal.
                """
                def __init__(self, service, version, mode, path):
                    self.run = self.__class__.run(service, version, mode, path + ["run"])
                    self.set = self.__class__.set(service, version, mode, path + ["set"])
                    super().__init__(service, version, mode, path)
                class run(TUIMethod):
                    """
                    Make inverse DFT recontruction.
                    """
                class set(TUIMethod):
                    """
                    Set reconstruction parameters.
                    """

            class keyframe_animation(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.set_custom_frames = self.__class__.set_custom_frames(service, version, mode, path + ["set_custom_frames"])
                    self.add_keyframe = self.__class__.add_keyframe(service, version, mode, path + ["add_keyframe"])
                    self.delete_all_keyframes = self.__class__.delete_all_keyframes(service, version, mode, path + ["delete_all_keyframes"])
                    self.delete_keyframe = self.__class__.delete_keyframe(service, version, mode, path + ["delete_keyframe"])
                    self.play = self.__class__.play(service, version, mode, path + ["play"])
                    self.read_animation = self.__class__.read_animation(service, version, mode, path + ["read_animation"])
                    self.write_animation = self.__class__.write_animation(service, version, mode, path + ["write_animation"])
                    super().__init__(service, version, mode, path)
                class add_keyframe(TUIMethod):
                    """
                    .
                    """
                class delete_all_keyframes(TUIMethod):
                    """
                    .
                    """
                class delete_keyframe(TUIMethod):
                    """
                    .
                    """
                class play(TUIMethod):
                    """
                    .
                    """
                class read_animation(TUIMethod):
                    """
                    .
                    """
                class write_animation(TUIMethod):
                    """
                    .
                    """

                class set_custom_frames(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.end_keyframe = self.__class__.end_keyframe(service, version, mode, path + ["end_keyframe"])
                        self.increment = self.__class__.increment(service, version, mode, path + ["increment"])
                        self.start_keyframe = self.__class__.start_keyframe(service, version, mode, path + ["start_keyframe"])
                        super().__init__(service, version, mode, path)
                    class end_keyframe(TUIMethod):
                        """
                        .
                        """
                    class increment(TUIMethod):
                        """
                        .
                        """
                    class start_keyframe(TUIMethod):
                        """
                        .
                        """

            class objects(TUIMenu):
                """
                Enter to define, edit, delete solution animation objects.
                """
                def __init__(self, service, version, mode, path):
                    self.clear_history = self.__class__.clear_history(service, version, mode, path + ["clear_history"])
                    self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                    self.create = self.__class__.create(service, version, mode, path + ["create"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                    self.get_window_id = self.__class__.get_window_id(service, version, mode, path + ["get_window_id"])
                    super().__init__(service, version, mode, path)
                class clear_history(TUIMethod):
                    """
                    Clear object history.
                    """
                class copy(TUIMethod):
                    """
                    Copy graphics object.
                    """
                class create(TUIMethod):
                    """
                    Create new graphics object.
                    """
                class delete(TUIMethod):
                    """
                    Delete graphics object.
                    """
                class edit(TUIMethod):
                    """
                    Edit graphics object.
                    """
                class get_window_id(TUIMethod):
                    """
                    Get animation object window id.
                    """

            class playback(TUIMenu):
                """
                Enter animation playback menu.
                """
                def __init__(self, service, version, mode, path):
                    self.video = self.__class__.video(service, version, mode, path + ["video"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.play = self.__class__.play(service, version, mode, path + ["play"])
                    self.read = self.__class__.read(service, version, mode, path + ["read"])
                    self.set_custom_frames = self.__class__.set_custom_frames(service, version, mode, path + ["set_custom_frames"])
                    self.stored_view = self.__class__.stored_view(service, version, mode, path + ["stored_view"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    super().__init__(service, version, mode, path)
                class delete(TUIMethod):
                    """
                    .
                    """
                class play(TUIMethod):
                    """
                    Play the selected animation.
                    """
                class read(TUIMethod):
                    """
                    Read new animation from file or already-defined animations.
                    """
                class set_custom_frames(TUIMethod):
                    """
                    Set custom frames start, end, skip frames for video export.
                    """
                class stored_view(TUIMethod):
                    """
                    Play the 3D animation sequence using the view stored in the sequence.
                    """
                class write(TUIMethod):
                    """
                    Write animation sequence to the file.
                    """

                class video(TUIMenu):
                    """
                    Set options for exporting video file menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.advance_quality = self.__class__.advance_quality(service, version, mode, path + ["advance_quality"])
                        self.format = self.__class__.format(service, version, mode, path + ["format"])
                        self.fps = self.__class__.fps(service, version, mode, path + ["fps"])
                        self.height = self.__class__.height(service, version, mode, path + ["height"])
                        self.name = self.__class__.name(service, version, mode, path + ["name"])
                        self.quality = self.__class__.quality(service, version, mode, path + ["quality"])
                        self.scale = self.__class__.scale(service, version, mode, path + ["scale"])
                        self.set_standard_resolution = self.__class__.set_standard_resolution(service, version, mode, path + ["set_standard_resolution"])
                        self.use_original_resolution = self.__class__.use_original_resolution(service, version, mode, path + ["use_original_resolution"])
                        self.width = self.__class__.width(service, version, mode, path + ["width"])
                        super().__init__(service, version, mode, path)
                    class format(TUIMethod):
                        """
                        Set format for exporting video file.
                        """
                    class fps(TUIMethod):
                        """
                        Set the Frame Per Sec(FPS) for exporting video file.
                        """
                    class height(TUIMethod):
                        """
                        Set the height for exporting video file.
                        """
                    class name(TUIMethod):
                        """
                        Exporting video file name.
                        """
                    class quality(TUIMethod):
                        """
                        Set quality for exporting video file.
                        """
                    class scale(TUIMethod):
                        """
                        Set scale by which video resolution will expand.
                        """
                    class set_standard_resolution(TUIMethod):
                        """
                        Select from pre-defined resolution list.
                        """
                    class use_original_resolution(TUIMethod):
                        """
                        Enable original resolution.
                        """
                    class width(TUIMethod):
                        """
                        Set the width for exporting video file.
                        """

                    class advance_quality(TUIMenu):
                        """
                        Advance Quality setting.
                        """
                        def __init__(self, service, version, mode, path):
                            self.bitrate = self.__class__.bitrate(service, version, mode, path + ["bitrate"])
                            self.bitrate_scale = self.__class__.bitrate_scale(service, version, mode, path + ["bitrate_scale"])
                            self.compression_method = self.__class__.compression_method(service, version, mode, path + ["compression_method"])
                            self.enable_h264 = self.__class__.enable_h264(service, version, mode, path + ["enable_h264"])
                            self.keyframe = self.__class__.keyframe(service, version, mode, path + ["keyframe"])
                            super().__init__(service, version, mode, path)
                        class bitrate(TUIMethod):
                            """
                            Set video bitrate(kbits/sec) for exporting video file.
                            """
                        class bitrate_scale(TUIMethod):
                            """
                            Mp4 bitrate scale - Best-64000 High-32000 Medium-16000 Low-8000.
                            """
                        class compression_method(TUIMethod):
                            """
                            Compression methode for Microsoft AVI movie.
                            """
                        class enable_h264(TUIMethod):
                            """
                            H264 encoding flag.
                            """
                        class keyframe(TUIMethod):
                            """
                            Set video keyframe rate for exporting video file.
                            """

            class pulse(TUIMenu):
                """
                Enter save pulse menu.
                """
                def __init__(self, service, version, mode, path):
                    self.hardcopy = self.__class__.hardcopy(service, version, mode, path + ["hardcopy"])
                    self.video = self.__class__.video(service, version, mode, path + ["video"])
                    self.pulse_mode = self.__class__.pulse_mode(service, version, mode, path + ["pulse_mode"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    super().__init__(service, version, mode, path)
                class pulse_mode(TUIMethod):
                    """
                    Set pulse-mode.
                    """
                class write(TUIMethod):
                    """
                    Exporting pulse.
                    """

                class hardcopy(TUIMenu):
                    """
                    Hardcopy options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.color_mode = self.__class__.color_mode(service, version, mode, path + ["color_mode"])
                        self.driver = self.__class__.driver(service, version, mode, path + ["driver"])
                        self.dpi = self.__class__.dpi(service, version, mode, path + ["dpi"])
                        self.invert_background = self.__class__.invert_background(service, version, mode, path + ["invert_background"])
                        self.invert_normals_for_avz = self.__class__.invert_normals_for_avz(service, version, mode, path + ["invert_normals_for_avz"])
                        self.jpeg_hardcopy_quality = self.__class__.jpeg_hardcopy_quality(service, version, mode, path + ["jpeg_hardcopy_quality"])
                        self.landscape = self.__class__.landscape(service, version, mode, path + ["landscape"])
                        self.preview = self.__class__.preview(service, version, mode, path + ["preview"])
                        self.raytracer_image = self.__class__.raytracer_image(service, version, mode, path + ["raytracer_image"])
                        self.set_standard_resolution = self.__class__.set_standard_resolution(service, version, mode, path + ["set_standard_resolution"])
                        self.use_window_resolution = self.__class__.use_window_resolution(service, version, mode, path + ["use_window_resolution"])
                        self.x_resolution = self.__class__.x_resolution(service, version, mode, path + ["x_resolution"])
                        self.y_resolution = self.__class__.y_resolution(service, version, mode, path + ["y_resolution"])
                        super().__init__(service, version, mode, path)
                    class dpi(TUIMethod):
                        """
                        Set the DPI for EPS and Postscript files, specifies the resolution in dots per inch (DPI) instead of setting the width and height.
                        """
                    class invert_background(TUIMethod):
                        """
                        Use a white background when the picture is saved.
                        """
                    class invert_normals_for_avz(TUIMethod):
                        """
                        In some cases, images exported to AVZ appear dark and do not match the true colors seen in the graphics window display. Enable 'invert-normals-for-avz' if you experience this issue.
                        """
                    class jpeg_hardcopy_quality(TUIMethod):
                        """
                        To set jpeg hardcopy quality.
                        """
                    class landscape(TUIMethod):
                        """
                        Plot hardcopies in landscape or portrait orientation.
                        """
                    class preview(TUIMethod):
                        """
                        Display a preview image of a hardcopy.
                        """
                    class raytracer_image(TUIMethod):
                        """
                        Enable raytracering rendering.
                        """
                    class set_standard_resolution(TUIMethod):
                        """
                        Select from pre-defined resolution list.
                        """
                    class use_window_resolution(TUIMethod):
                        """
                        Use the currently active window's resolution for hardcopy (ignores the x-resolution and y-resolution in this case).
                        """
                    class x_resolution(TUIMethod):
                        """
                        Set the width of raster-formatted images in pixels (0 implies current window size).
                        """
                    class y_resolution(TUIMethod):
                        """
                        Set the height of raster-formatted images in pixels (0 implies current window size).
                        """

                    class color_mode(TUIMenu):
                        """
                        Enter the hardcopy color mode menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.color = self.__class__.color(service, version, mode, path + ["color"])
                            self.gray_scale = self.__class__.gray_scale(service, version, mode, path + ["gray_scale"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.mono_chrome = self.__class__.mono_chrome(service, version, mode, path + ["mono_chrome"])
                            super().__init__(service, version, mode, path)
                        class color(TUIMethod):
                            """
                            Plot hardcopies in color.
                            """
                        class gray_scale(TUIMethod):
                            """
                            Convert color to grayscale for hardcopy.
                            """
                        class list(TUIMethod):
                            """
                            Display the current hardcopy color mode.
                            """
                        class mono_chrome(TUIMethod):
                            """
                            Convert color to monochrome (black and white) for hardcopy.
                            """

                    class driver(TUIMenu):
                        """
                        Enter the set hardcopy driver menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.post_format = self.__class__.post_format(service, version, mode, path + ["post_format"])
                            self.avz = self.__class__.avz(service, version, mode, path + ["avz"])
                            self.dump_window = self.__class__.dump_window(service, version, mode, path + ["dump_window"])
                            self.eps = self.__class__.eps(service, version, mode, path + ["eps"])
                            self.glb = self.__class__.glb(service, version, mode, path + ["glb"])
                            self.hsf = self.__class__.hsf(service, version, mode, path + ["hsf"])
                            self.jpeg = self.__class__.jpeg(service, version, mode, path + ["jpeg"])
                            self.list = self.__class__.list(service, version, mode, path + ["list"])
                            self.options = self.__class__.options(service, version, mode, path + ["options"])
                            self.png = self.__class__.png(service, version, mode, path + ["png"])
                            self.post_script = self.__class__.post_script(service, version, mode, path + ["post_script"])
                            self.ppm = self.__class__.ppm(service, version, mode, path + ["ppm"])
                            self.tiff = self.__class__.tiff(service, version, mode, path + ["tiff"])
                            self.vrml = self.__class__.vrml(service, version, mode, path + ["vrml"])
                            super().__init__(service, version, mode, path)
                        class avz(TUIMethod):
                            """
                            Use AVZ output for hardcopies.
                            """
                        class dump_window(TUIMethod):
                            """
                            Set the command used to dump the graphics window to a file.
                            """
                        class eps(TUIMethod):
                            """
                            Produce encapsulated PostScript (EPS) output for hardcopies.
                            """
                        class glb(TUIMethod):
                            """
                            Use GLB output for hardcopies.
                            """
                        class hsf(TUIMethod):
                            """
                            Use HSF output for hardcopies.
                            """
                        class jpeg(TUIMethod):
                            """
                            Produce JPEG output for hardcopies.
                            """
                        class list(TUIMethod):
                            """
                            List the current hardcopy driver.
                            """
                        class options(TUIMethod):
                            """
                            Set the hardcopy options. Available options are:
                            "no gamma correction", disables gamma correction of colors,
                            "physical size = (width,height)", where width and height
                            are the actual measurements of the printable area of the page
                            in centimeters.
                            "subscreen = (left,right,bottom,top)", where left,right,
                            bottom, and top are numbers in [-1,1] describing a subwindow on
                            the page in which to place the hardcopy.
                            The options may be combined by separating them with commas.
                            """
                        class png(TUIMethod):
                            """
                            Use PNG output for hardcopies.
                            """
                        class post_script(TUIMethod):
                            """
                            Produce PostScript output for hardcopies.
                            """
                        class ppm(TUIMethod):
                            """
                            Produce PPM output for hardcopies.
                            """
                        class tiff(TUIMethod):
                            """
                            Use TIFF output for hardcopies.
                            """
                        class vrml(TUIMethod):
                            """
                            Use VRML output for hardcopies.
                            """

                        class post_format(TUIMenu):
                            """
                            Enter the PostScript driver format menu.
                            """
                            def __init__(self, service, version, mode, path):
                                self.fast_raster = self.__class__.fast_raster(service, version, mode, path + ["fast_raster"])
                                self.raster = self.__class__.raster(service, version, mode, path + ["raster"])
                                self.rle_raster = self.__class__.rle_raster(service, version, mode, path + ["rle_raster"])
                                self.vector = self.__class__.vector(service, version, mode, path + ["vector"])
                                super().__init__(service, version, mode, path)
                            class fast_raster(TUIMethod):
                                """
                                Use the new raster format.
                                """
                            class raster(TUIMethod):
                                """
                                Use the original raster format.
                                """
                            class rle_raster(TUIMethod):
                                """
                                Use the run-length encoded raster format.
                                """
                            class vector(TUIMethod):
                                """
                                Use vector format.
                                """

                class video(TUIMenu):
                    """
                    Enter the video window options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.advance_quality = self.__class__.advance_quality(service, version, mode, path + ["advance_quality"])
                        self.format = self.__class__.format(service, version, mode, path + ["format"])
                        self.fps = self.__class__.fps(service, version, mode, path + ["fps"])
                        self.height = self.__class__.height(service, version, mode, path + ["height"])
                        self.name = self.__class__.name(service, version, mode, path + ["name"])
                        self.quality = self.__class__.quality(service, version, mode, path + ["quality"])
                        self.scale = self.__class__.scale(service, version, mode, path + ["scale"])
                        self.set_standard_resolution = self.__class__.set_standard_resolution(service, version, mode, path + ["set_standard_resolution"])
                        self.use_original_resolution = self.__class__.use_original_resolution(service, version, mode, path + ["use_original_resolution"])
                        self.width = self.__class__.width(service, version, mode, path + ["width"])
                        super().__init__(service, version, mode, path)
                    class format(TUIMethod):
                        """
                        Set format for exporting video file.
                        """
                    class fps(TUIMethod):
                        """
                        Set the Frame Per Sec(FPS) for exporting video file.
                        """
                    class height(TUIMethod):
                        """
                        Set the height for exporting video file.
                        """
                    class name(TUIMethod):
                        """
                        Exporting video file name.
                        """
                    class quality(TUIMethod):
                        """
                        Set quality for exporting video file.
                        """
                    class scale(TUIMethod):
                        """
                        Set scale by which video resolution will expand.
                        """
                    class set_standard_resolution(TUIMethod):
                        """
                        Select from pre-defined resolution list.
                        """
                    class use_original_resolution(TUIMethod):
                        """
                        Enable original resolution.
                        """
                    class width(TUIMethod):
                        """
                        Set the width for exporting video file.
                        """

                    class advance_quality(TUIMenu):
                        """
                        Advance Quality setting.
                        """
                        def __init__(self, service, version, mode, path):
                            self.bitrate = self.__class__.bitrate(service, version, mode, path + ["bitrate"])
                            self.bitrate_scale = self.__class__.bitrate_scale(service, version, mode, path + ["bitrate_scale"])
                            self.compression_method = self.__class__.compression_method(service, version, mode, path + ["compression_method"])
                            self.enable_h264 = self.__class__.enable_h264(service, version, mode, path + ["enable_h264"])
                            self.keyframe = self.__class__.keyframe(service, version, mode, path + ["keyframe"])
                            super().__init__(service, version, mode, path)
                        class bitrate(TUIMethod):
                            """
                            Set video bitrate(kbits/sec) for exporting video file.
                            """
                        class bitrate_scale(TUIMethod):
                            """
                            Mp4 bitrate scale - Best-64000 High-32000 Medium-16000 Low-8000.
                            """
                        class compression_method(TUIMethod):
                            """
                            Compression methode for Microsoft AVI movie.
                            """
                        class enable_h264(TUIMethod):
                            """
                            H264 encoding flag.
                            """
                        class keyframe(TUIMethod):
                            """
                            Set video keyframe rate for exporting video file.
                            """

        class cell_register_operations(TUIMenu):
            """
            Manage Cell Register Operations.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """

        class cell_registers(TUIMenu):
            """
            Manage Cell Registers.
            """
            def __init__(self, service, version, mode, path):
                self.adapt = self.__class__.adapt(service, version, mode, path + ["adapt"])
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.apply_poor_mesh_numerics = self.__class__.apply_poor_mesh_numerics(service, version, mode, path + ["apply_poor_mesh_numerics"])
                self.coarsen = self.__class__.coarsen(service, version, mode, path + ["coarsen"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.display = self.__class__.display(service, version, mode, path + ["display"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.refine = self.__class__.refine(service, version, mode, path + ["refine"])
                super().__init__(service, version, mode, path)
            class adapt(TUIMethod):
                """
                Adapt cell register objects.
                """
            class add(TUIMethod):
                """
                Add a new object.
                """
            class apply_poor_mesh_numerics(TUIMethod):
                """
                Apply poor mesh numerics to cell register objects.
                """
            class coarsen(TUIMethod):
                """
                Coarsen cell register objects.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class display(TUIMethod):
                """
                Display cell register objects.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """
            class refine(TUIMethod):
                """
                Refine cell register objects.
                """

        class execute_commands(TUIMenu):
            """
            Enter the execute-monitor-commands menu.
            """
            def __init__(self, service, version, mode, path):
                self.add_edit = self.__class__.add_edit(service, version, mode, path + ["add_edit"])
                self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.disable = self.__class__.disable(service, version, mode, path + ["disable"])
                self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                self.export = self.__class__.export(service, version, mode, path + ["export"])
                self.import_ = self.__class__.import_(service, version, mode, path + ["import_"])
                super().__init__(service, version, mode, path)
            class add_edit(TUIMethod):
                """
                Add or edit execute-commands.
                """
            class copy(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class disable(TUIMethod):
                """
                .
                """
            class enable(TUIMethod):
                """
                .
                """
            class export(TUIMethod):
                """
                .
                """
            class import_(TUIMethod):
                """
                .
                """

        class initialize(TUIMenu):
            """
            Enter the flow initialization menu.
            """
            def __init__(self, service, version, mode, path):
                self.compute_defaults = self.__class__.compute_defaults(service, version, mode, path + ["compute_defaults"])
                self.mp_localized_turb_init = self.__class__.mp_localized_turb_init(service, version, mode, path + ["mp_localized_turb_init"])
                self.set_hyb_initialization = self.__class__.set_hyb_initialization(service, version, mode, path + ["set_hyb_initialization"])
                self.vof_patch_smooth_options = self.__class__.vof_patch_smooth_options(service, version, mode, path + ["vof_patch_smooth_options"])
                self.dpm_reset = self.__class__.dpm_reset(service, version, mode, path + ["dpm_reset"])
                self.enable_profile_memory_flushing = self.__class__.enable_profile_memory_flushing(service, version, mode, path + ["enable_profile_memory_flushing"])
                self.fmg_initialization = self.__class__.fmg_initialization(service, version, mode, path + ["fmg_initialization"])
                self.hyb_initialization = self.__class__.hyb_initialization(service, version, mode, path + ["hyb_initialization"])
                self.init_acoustics_options = self.__class__.init_acoustics_options(service, version, mode, path + ["init_acoustics_options"])
                self.init_flow_statistics = self.__class__.init_flow_statistics(service, version, mode, path + ["init_flow_statistics"])
                self.init_instantaneous_vel = self.__class__.init_instantaneous_vel(service, version, mode, path + ["init_instantaneous_vel"])
                self.init_turb_vel_fluctuations = self.__class__.init_turb_vel_fluctuations(service, version, mode, path + ["init_turb_vel_fluctuations"])
                self.initialize_flow = self.__class__.initialize_flow(service, version, mode, path + ["initialize_flow"])
                self.initialize_lwf = self.__class__.initialize_lwf(service, version, mode, path + ["initialize_lwf"])
                self.levelset_auto_init = self.__class__.levelset_auto_init(service, version, mode, path + ["levelset_auto_init"])
                self.list_defaults = self.__class__.list_defaults(service, version, mode, path + ["list_defaults"])
                self.lwf_reset = self.__class__.lwf_reset(service, version, mode, path + ["lwf_reset"])
                self.open_channel_auto_init = self.__class__.open_channel_auto_init(service, version, mode, path + ["open_channel_auto_init"])
                self.reference_frame = self.__class__.reference_frame(service, version, mode, path + ["reference_frame"])
                self.repair_wall_distance = self.__class__.repair_wall_distance(service, version, mode, path + ["repair_wall_distance"])
                self.set_defaults = self.__class__.set_defaults(service, version, mode, path + ["set_defaults"])
                self.set_fmg_initialization = self.__class__.set_fmg_initialization(service, version, mode, path + ["set_fmg_initialization"])
                self.set_fmg_options = self.__class__.set_fmg_options(service, version, mode, path + ["set_fmg_options"])
                self.show_iterations_sampled = self.__class__.show_iterations_sampled(service, version, mode, path + ["show_iterations_sampled"])
                self.show_time_sampled = self.__class__.show_time_sampled(service, version, mode, path + ["show_time_sampled"])
                super().__init__(service, version, mode, path)
            class dpm_reset(TUIMethod):
                """
                .
                """
            class enable_profile_memory_flushing(TUIMethod):
                """
                .
                """
            class fmg_initialization(TUIMethod):
                """
                .
                """
            class hyb_initialization(TUIMethod):
                """
                .
                """
            class init_acoustics_options(TUIMethod):
                """
                .
                """
            class init_flow_statistics(TUIMethod):
                """
                .
                """
            class init_instantaneous_vel(TUIMethod):
                """
                Initialize unsteady velocity.
                """
            class init_turb_vel_fluctuations(TUIMethod):
                """
                .
                """
            class initialize_flow(TUIMethod):
                """
                .
                """
            class initialize_lwf(TUIMethod):
                """
                Initalize Lagrangian wall film according to the settings made for individual wall zones.
                """
            class levelset_auto_init(TUIMethod):
                """
                .
                """
            class list_defaults(TUIMethod):
                """
                .
                """
            class lwf_reset(TUIMethod):
                """
                Delete wall film particles and initialize wall film variables to zero.
                """
            class open_channel_auto_init(TUIMethod):
                """
                .
                """
            class reference_frame(TUIMethod):
                """
                .
                """
            class repair_wall_distance(TUIMethod):
                """
                .
                """
            class set_defaults(TUIMethod):
                """
                Enter the set defaults menu.
                """
            class set_fmg_initialization(TUIMethod):
                """
                Enter the set full-multigrid for initialization menu.
                """
            class set_fmg_options(TUIMethod):
                """
                Enter the additional fmg options menu.
                """
            class show_iterations_sampled(TUIMethod):
                """
                .
                """
            class show_time_sampled(TUIMethod):
                """
                .
                """

            class compute_defaults(TUIMenu):
                """
                Enter the compute defaults menu.
                """
                def __init__(self, service, version, mode, path):
                    self.all_zones = self.__class__.all_zones(service, version, mode, path + ["all_zones"])
                    self.axis = self.__class__.axis(service, version, mode, path + ["axis"])
                    self.degassing = self.__class__.degassing(service, version, mode, path + ["degassing"])
                    self.dummy_entry = self.__class__.dummy_entry(service, version, mode, path + ["dummy_entry"])
                    self.exhaust_fan = self.__class__.exhaust_fan(service, version, mode, path + ["exhaust_fan"])
                    self.fan = self.__class__.fan(service, version, mode, path + ["fan"])
                    self.fluid = self.__class__.fluid(service, version, mode, path + ["fluid"])
                    self.geometry = self.__class__.geometry(service, version, mode, path + ["geometry"])
                    self.inlet_vent = self.__class__.inlet_vent(service, version, mode, path + ["inlet_vent"])
                    self.intake_fan = self.__class__.intake_fan(service, version, mode, path + ["intake_fan"])
                    self.interface = self.__class__.interface(service, version, mode, path + ["interface"])
                    self.interior = self.__class__.interior(service, version, mode, path + ["interior"])
                    self.mass_flow_inlet = self.__class__.mass_flow_inlet(service, version, mode, path + ["mass_flow_inlet"])
                    self.mass_flow_outlet = self.__class__.mass_flow_outlet(service, version, mode, path + ["mass_flow_outlet"])
                    self.network = self.__class__.network(service, version, mode, path + ["network"])
                    self.network_end = self.__class__.network_end(service, version, mode, path + ["network_end"])
                    self.outflow = self.__class__.outflow(service, version, mode, path + ["outflow"])
                    self.outlet_vent = self.__class__.outlet_vent(service, version, mode, path + ["outlet_vent"])
                    self.overset = self.__class__.overset(service, version, mode, path + ["overset"])
                    self.periodic = self.__class__.periodic(service, version, mode, path + ["periodic"])
                    self.porous_jump = self.__class__.porous_jump(service, version, mode, path + ["porous_jump"])
                    self.pressure_far_field = self.__class__.pressure_far_field(service, version, mode, path + ["pressure_far_field"])
                    self.pressure_inlet = self.__class__.pressure_inlet(service, version, mode, path + ["pressure_inlet"])
                    self.pressure_outlet = self.__class__.pressure_outlet(service, version, mode, path + ["pressure_outlet"])
                    self.radiator = self.__class__.radiator(service, version, mode, path + ["radiator"])
                    self.rans_les_interface = self.__class__.rans_les_interface(service, version, mode, path + ["rans_les_interface"])
                    self.recirculation_inlet = self.__class__.recirculation_inlet(service, version, mode, path + ["recirculation_inlet"])
                    self.recirculation_outlet = self.__class__.recirculation_outlet(service, version, mode, path + ["recirculation_outlet"])
                    self.shadow = self.__class__.shadow(service, version, mode, path + ["shadow"])
                    self.solid = self.__class__.solid(service, version, mode, path + ["solid"])
                    self.symmetry = self.__class__.symmetry(service, version, mode, path + ["symmetry"])
                    self.velocity_inlet = self.__class__.velocity_inlet(service, version, mode, path + ["velocity_inlet"])
                    self.wall = self.__class__.wall(service, version, mode, path + ["wall"])
                    super().__init__(service, version, mode, path)
                class all_zones(TUIMethod):
                    """
                    Initialize the flow field with the default values.
                    """
                class axis(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class degassing(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class dummy_entry(TUIMethod):
                    """
                    .
                    """
                class exhaust_fan(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class fan(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class fluid(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class geometry(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class inlet_vent(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class intake_fan(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class interface(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class interior(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class mass_flow_inlet(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class mass_flow_outlet(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class network(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class network_end(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class outflow(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class outlet_vent(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class overset(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class periodic(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class porous_jump(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class pressure_far_field(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class pressure_inlet(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class pressure_outlet(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class radiator(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class rans_les_interface(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class recirculation_inlet(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class recirculation_outlet(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class shadow(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class solid(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class symmetry(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class velocity_inlet(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """
                class wall(TUIMethod):
                    """
                    Compute flow-initialization defaults from a zone of this type.
                    """

            class mp_localized_turb_init(TUIMenu):
                """
                Localized initialization of turbulent flow variables for VOF/Mixture multiphase flow models.
                """
                def __init__(self, service, version, mode, path):
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.turb_init_parameters = self.__class__.turb_init_parameters(service, version, mode, path + ["turb_init_parameters"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    .
                    """
                class turb_init_parameters(TUIMethod):
                    """
                    Turbulent flow parameters for localized initialization.
                    """

            class set_hyb_initialization(TUIMenu):
                """
                Enter the settings for hybrid initialization method.
                """
                def __init__(self, service, version, mode, path):
                    self.general_settings = self.__class__.general_settings(service, version, mode, path + ["general_settings"])
                    self.species_settings = self.__class__.species_settings(service, version, mode, path + ["species_settings"])
                    self.turbulent_settings = self.__class__.turbulent_settings(service, version, mode, path + ["turbulent_settings"])
                    super().__init__(service, version, mode, path)
                class general_settings(TUIMethod):
                    """
                    Enter the general settings menu.
                    """
                class species_settings(TUIMethod):
                    """
                    Enter the species settings menu.
                    """
                class turbulent_settings(TUIMethod):
                    """
                    Enter the turbulent settings menu.
                    """

            class vof_patch_smooth_options(TUIMenu):
                """
                Enter the vof patch/smooth options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.execute_smoothing = self.__class__.execute_smoothing(service, version, mode, path + ["execute_smoothing"])
                    self.set_options = self.__class__.set_options(service, version, mode, path + ["set_options"])
                    super().__init__(service, version, mode, path)
                class execute_smoothing(TUIMethod):
                    """
                    .
                    """
                class set_options(TUIMethod):
                    """
                    .
                    """

        class monitors(TUIMenu):
            """
            Enter the monitors menu.
            """
            def __init__(self, service, version, mode, path):
                self.convergence = self.__class__.convergence(service, version, mode, path + ["convergence"])
                self.force = self.__class__.force(service, version, mode, path + ["force"])
                self.residual = self.__class__.residual(service, version, mode, path + ["residual"])
                self.statistic = self.__class__.statistic(service, version, mode, path + ["statistic"])
                self.surface = self.__class__.surface(service, version, mode, path + ["surface"])
                self.volume = self.__class__.volume(service, version, mode, path + ["volume"])
                self.set_average_over = self.__class__.set_average_over(service, version, mode, path + ["set_average_over"])
                super().__init__(service, version, mode, path)
            class set_average_over(TUIMethod):
                """
                Set the average over input for monitors.
                """

            class convergence(TUIMenu):
                """
                Enter the convergence menu to add surface, volume, drag, lift and moment monitors to convergence criteria.
                """
                def __init__(self, service, version, mode, path):
                    self.add_edit = self.__class__.add_edit(service, version, mode, path + ["add_edit"])
                    self.average_over_last_n_iterations_timesteps = self.__class__.average_over_last_n_iterations_timesteps(service, version, mode, path + ["average_over_last_n_iterations_timesteps"])
                    self.condition = self.__class__.condition(service, version, mode, path + ["condition"])
                    self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                    self.frequency = self.__class__.frequency(service, version, mode, path + ["frequency"])
                    self.list = self.__class__.list(service, version, mode, path + ["list"])
                    super().__init__(service, version, mode, path)
                class add_edit(TUIMethod):
                    """
                    Add or edit convergence criterion for surface, volume, drag, lift and moment monitors.
                    """
                class average_over_last_n_iterations_timesteps(TUIMethod):
                    """
                    Option to average over previous values for checking convergence.
                    """
                class condition(TUIMethod):
                    """
                    Option to stop the calculations. All convergence conditions are met or any convergence condition is met.
                    """
                class delete(TUIMethod):
                    """
                    Delete a monitor from convergence criteria.
                    """
                class frequency(TUIMethod):
                    """
                    To set how often convergence checks are done with respect to iterations or time steps.
                    """
                class list(TUIMethod):
                    """
                    List defined convergence criteria for monitors.
                    """

            class force(TUIMenu):
                """
                Enter the force monitors menu.
                """
                def __init__(self, service, version, mode, path):
                    self.clear_all_monitors_data = self.__class__.clear_all_monitors_data(service, version, mode, path + ["clear_all_monitors_data"])
                    self.clear_drag_monitor_data = self.__class__.clear_drag_monitor_data(service, version, mode, path + ["clear_drag_monitor_data"])
                    self.clear_lift_monitor_data = self.__class__.clear_lift_monitor_data(service, version, mode, path + ["clear_lift_monitor_data"])
                    self.clear_moment_monitor_data = self.__class__.clear_moment_monitor_data(service, version, mode, path + ["clear_moment_monitor_data"])
                    self.clear_monitors = self.__class__.clear_monitors(service, version, mode, path + ["clear_monitors"])
                    self.delete_monitors = self.__class__.delete_monitors(service, version, mode, path + ["delete_monitors"])
                    self.drag_coefficient = self.__class__.drag_coefficient(service, version, mode, path + ["drag_coefficient"])
                    self.lift_coefficient = self.__class__.lift_coefficient(service, version, mode, path + ["lift_coefficient"])
                    self.list_monitors = self.__class__.list_monitors(service, version, mode, path + ["list_monitors"])
                    self.moment_coefficient = self.__class__.moment_coefficient(service, version, mode, path + ["moment_coefficient"])
                    self.monitor_unsteady_iters = self.__class__.monitor_unsteady_iters(service, version, mode, path + ["monitor_unsteady_iters"])
                    self.set_drag_monitor = self.__class__.set_drag_monitor(service, version, mode, path + ["set_drag_monitor"])
                    self.set_lift_monitor = self.__class__.set_lift_monitor(service, version, mode, path + ["set_lift_monitor"])
                    self.set_moment_monitor = self.__class__.set_moment_monitor(service, version, mode, path + ["set_moment_monitor"])
                    self.unscaled = self.__class__.unscaled(service, version, mode, path + ["unscaled"])
                    super().__init__(service, version, mode, path)
                class clear_all_monitors_data(TUIMethod):
                    """
                    Clear all monitoring data.
                    """
                class clear_drag_monitor_data(TUIMethod):
                    """
                    Clear the drag monitoring data.
                    """
                class clear_lift_monitor_data(TUIMethod):
                    """
                    Clear the lift monitoring data.
                    """
                class clear_moment_monitor_data(TUIMethod):
                    """
                    Clear the moment monitoring data.
                    """
                class clear_monitors(TUIMethod):
                    """
                    Clear all or specified monitor data.
                    """
                class delete_monitors(TUIMethod):
                    """
                    Delete the specified monitor.
                    """
                class drag_coefficient(TUIMethod):
                    """
                    Set variables for monitoring the drag coefficient.
                    """
                class lift_coefficient(TUIMethod):
                    """
                    Set variables for monitoring the lift coefficient.
                    """
                class list_monitors(TUIMethod):
                    """
                    List defined force monitors.
                    """
                class moment_coefficient(TUIMethod):
                    """
                    Set variables for monitoring the moment coefficient.
                    """
                class monitor_unsteady_iters(TUIMethod):
                    """
                    Specify whether monitors are updated every iteration or every time step for transient calculations.
                    """
                class set_drag_monitor(TUIMethod):
                    """
                    Set variables for monitoring the drag coefficient.
                    """
                class set_lift_monitor(TUIMethod):
                    """
                    Set variables for monitoring the lift coefficient.
                    """
                class set_moment_monitor(TUIMethod):
                    """
                    Set variables for monitoring the moment coefficient.
                    """
                class unscaled(TUIMethod):
                    """
                    Specify whether unscaled values are desired.
                    """

            class residual(TUIMenu):
                """
                Enter the residual monitors menu.
                """
                def __init__(self, service, version, mode, path):
                    self.check_convergence = self.__class__.check_convergence(service, version, mode, path + ["check_convergence"])
                    self.convergence_criteria = self.__class__.convergence_criteria(service, version, mode, path + ["convergence_criteria"])
                    self.criterion_type = self.__class__.criterion_type(service, version, mode, path + ["criterion_type"])
                    self.enhanced_continuity_residual = self.__class__.enhanced_continuity_residual(service, version, mode, path + ["enhanced_continuity_residual"])
                    self.monitor = self.__class__.monitor(service, version, mode, path + ["monitor"])
                    self.n_display = self.__class__.n_display(service, version, mode, path + ["n_display"])
                    self.n_maximize_norms = self.__class__.n_maximize_norms(service, version, mode, path + ["n_maximize_norms"])
                    self.n_save = self.__class__.n_save(service, version, mode, path + ["n_save"])
                    self.normalization_factors = self.__class__.normalization_factors(service, version, mode, path + ["normalization_factors"])
                    self.normalize = self.__class__.normalize(service, version, mode, path + ["normalize"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    self.print = self.__class__.print(service, version, mode, path + ["print"])
                    self.re_normalize = self.__class__.re_normalize(service, version, mode, path + ["re_normalize"])
                    self.relative_conv_criteria = self.__class__.relative_conv_criteria(service, version, mode, path + ["relative_conv_criteria"])
                    self.reset = self.__class__.reset(service, version, mode, path + ["reset"])
                    self.scale_by_coefficient = self.__class__.scale_by_coefficient(service, version, mode, path + ["scale_by_coefficient"])
                    self.window = self.__class__.window(service, version, mode, path + ["window"])
                    super().__init__(service, version, mode, path)
                class check_convergence(TUIMethod):
                    """
                    Choose which currently-monitored residuals
                    should be checked for convergence.
                    """
                class convergence_criteria(TUIMethod):
                    """
                    Set convergence criteria for residuals which are
                    currently being both monitored and checked.
                    """
                class criterion_type(TUIMethod):
                    """
                    .
                    """
                class enhanced_continuity_residual(TUIMethod):
                    """
                    .
                    """
                class monitor(TUIMethod):
                    """
                    Choose which residuals to monitor as printed and/or plotted output.
                    """
                class n_display(TUIMethod):
                    """
                    .
                    """
                class n_maximize_norms(TUIMethod):
                    """
                    .
                    """
                class n_save(TUIMethod):
                    """
                    .
                    """
                class normalization_factors(TUIMethod):
                    """
                    Set normalization factors for currently-monitored residuals.
                    """
                class normalize(TUIMethod):
                    """
                    .
                    """
                class plot(TUIMethod):
                    """
                    .
                    """
                class print(TUIMethod):
                    """
                    .
                    """
                class re_normalize(TUIMethod):
                    """
                    Renormalize residuals by maximum values.
                    """
                class relative_conv_criteria(TUIMethod):
                    """
                    Set relative convergence criteria for residuals which are
                    currently being both monitored and checked.
                    """
                class reset(TUIMethod):
                    """
                    .
                    """
                class scale_by_coefficient(TUIMethod):
                    """
                    Enable/disable scaling of residuals by coefficient sum in printed and plotted output.
                    """
                class window(TUIMethod):
                    """
                    Specify window in which residuals will be plotted during iteration.
                    """

            class statistic(TUIMenu):
                """
                Enter the statistic monitors menu.
                """
                def __init__(self, service, version, mode, path):
                    self.file_basename = self.__class__.file_basename(service, version, mode, path + ["file_basename"])
                    self.monitors = self.__class__.monitors(service, version, mode, path + ["monitors"])
                    self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                    self.print = self.__class__.print(service, version, mode, path + ["print"])
                    self.window = self.__class__.window(service, version, mode, path + ["window"])
                    self.write = self.__class__.write(service, version, mode, path + ["write"])
                    self.x_axis = self.__class__.x_axis(service, version, mode, path + ["x_axis"])
                    super().__init__(service, version, mode, path)
                class file_basename(TUIMethod):
                    """
                    Specify the file basename and extension. The name of the individual monitor will be insterted automatically.
                    """
                class monitors(TUIMethod):
                    """
                    Choose which statistics to monitor as printed and/or plotted output.
                    """
                class plot(TUIMethod):
                    """
                    Enable/disable plotting of statistics during iteration.
                    """
                class print(TUIMethod):
                    """
                    Enable/disable printing of statistics during iteration.
                    """
                class window(TUIMethod):
                    """
                    Specify first window in which statistics will be plotted during iteration.
                    Multiple statistics are plotted in separate windows, beginning with this one.
                    """
                class write(TUIMethod):
                    """
                    Enable/disable writing of statistics during iteration.
                    """
                class x_axis(TUIMethod):
                    """
                    Choose what quantity to use on the abscissa in the plot and in the data written to files.
                    """

            class surface(TUIMenu):
                """
                Enter the surface menu to set integrated scalar quantities on surface(s) monitors.
                """
                def __init__(self, service, version, mode, path):
                    self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                    self.clear_data = self.__class__.clear_data(service, version, mode, path + ["clear_data"])
                    self.clear_monitors = self.__class__.clear_monitors(service, version, mode, path + ["clear_monitors"])
                    self.list_monitors = self.__class__.list_monitors(service, version, mode, path + ["list_monitors"])
                    self.set_monitor = self.__class__.set_monitor(service, version, mode, path + ["set_monitor"])
                    super().__init__(service, version, mode, path)
                class clear_data(TUIMethod):
                    """
                    Clear current surface monitor data.
                    """
                class clear_monitors(TUIMethod):
                    """
                    Remove all defined surface monitors.
                    """
                class list_monitors(TUIMethod):
                    """
                    List defined surface monitors.
                    """
                class set_monitor(TUIMethod):
                    """
                    Define or modify a surface monitor.
                    """

                class curves(TUIMenu):
                    """
                    Enter the curves menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.lines = self.__class__.lines(service, version, mode, path + ["lines"])
                        self.markers = self.__class__.markers(service, version, mode, path + ["markers"])
                        super().__init__(service, version, mode, path)
                    class lines(TUIMethod):
                        """
                        Set lines parameters for surface monitors.
                        """
                    class markers(TUIMethod):
                        """
                        Set markers parameters for surface monitors.
                        """

            class volume(TUIMenu):
                """
                Enter the volume menu to set integrated scalar quantities on volume(s) monitors.
                """
                def __init__(self, service, version, mode, path):
                    self.clear_data = self.__class__.clear_data(service, version, mode, path + ["clear_data"])
                    self.clear_monitors = self.__class__.clear_monitors(service, version, mode, path + ["clear_monitors"])
                    self.list_monitors = self.__class__.list_monitors(service, version, mode, path + ["list_monitors"])
                    self.set_monitor = self.__class__.set_monitor(service, version, mode, path + ["set_monitor"])
                    super().__init__(service, version, mode, path)
                class clear_data(TUIMethod):
                    """
                    Clear current volume monitor data.
                    """
                class clear_monitors(TUIMethod):
                    """
                    Remove all defined volume monitors.
                    """
                class list_monitors(TUIMethod):
                    """
                    List defined volume monitors.
                    """
                class set_monitor(TUIMethod):
                    """
                    Define or modify a volume monitor.
                    """

        class report_definitions(TUIMenu):
            """
            Manage report definitions.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.compute = self.__class__.compute(service, version, mode, path + ["compute"])
                self.convert_monitors_to_report_defns = self.__class__.convert_monitors_to_report_defns(service, version, mode, path + ["convert_monitors_to_report_defns"])
                self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class compute(TUIMethod):
                """
                Computes selected report definition.
                """
            class convert_monitors_to_report_defns(TUIMethod):
                """
                Converts all monitors to Report Definitions and create new Report Sets/Plot Sets if required.
                """
            class copy(TUIMethod):
                """
                Makes a copy of selected report definition with new name.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class delete_all(TUIMethod):
                """
                Delete all report definition objects.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """
            class rename(TUIMethod):
                """
                Rename selected report definition with new name.
                """

        class report_files(TUIMenu):
            """
            Manage report files.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.clear_data = self.__class__.clear_data(service, version, mode, path + ["clear_data"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class clear_data(TUIMethod):
                """
                Delete the report file from the system.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class delete_all(TUIMethod):
                """
                Delete all report file objects.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """

        class report_plots(TUIMenu):
            """
            Manage report plots.
            """
            def __init__(self, service, version, mode, path):
                self.add = self.__class__.add(service, version, mode, path + ["add"])
                self.axes = self.__class__.axes(service, version, mode, path + ["axes"])
                self.clear_data = self.__class__.clear_data(service, version, mode, path + ["clear_data"])
                self.curves = self.__class__.curves(service, version, mode, path + ["curves"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.delete_all = self.__class__.delete_all(service, version, mode, path + ["delete_all"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.get_window_id = self.__class__.get_window_id(service, version, mode, path + ["get_window_id"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.plot = self.__class__.plot(service, version, mode, path + ["plot"])
                super().__init__(service, version, mode, path)
            class add(TUIMethod):
                """
                Add a new object.
                """
            class axes(TUIMethod):
                """
                Set axes options of an object.
                """
            class clear_data(TUIMethod):
                """
                Clear report plot data.
                """
            class curves(TUIMethod):
                """
                Set curves options of an object.
                """
            class delete(TUIMethod):
                """
                Delete an object.
                """
            class delete_all(TUIMethod):
                """
                Delete all plot objects.
                """
            class edit(TUIMethod):
                """
                Edit an object.
                """
            class get_window_id(TUIMethod):
                """
                Get report-plot object window id.
                """
            class list(TUIMethod):
                """
                List objects.
                """
            class list_properties(TUIMethod):
                """
                List properties of an object.
                """
            class plot(TUIMethod):
                """
                Plot.
                """

        class set(TUIMenu):
            """
            Enter the set solution parameters menu.
            """
            def __init__(self, service, version, mode, path):
                self.acoustics_wave_equation_controls = self.__class__.acoustics_wave_equation_controls(service, version, mode, path + ["acoustics_wave_equation_controls"])
                self.advanced = self.__class__.advanced(service, version, mode, path + ["advanced"])
                self.amg_options = self.__class__.amg_options(service, version, mode, path + ["amg_options"])
                self.axisymmetric = self.__class__.axisymmetric(service, version, mode, path + ["axisymmetric"])
                self.contact_solution_controls = self.__class__.contact_solution_controls(service, version, mode, path + ["contact_solution_controls"])
                self.data_sampling_options = self.__class__.data_sampling_options(service, version, mode, path + ["data_sampling_options"])
                self.divergence_prevention = self.__class__.divergence_prevention(service, version, mode, path + ["divergence_prevention"])
                self.enhanced_les_numerics = self.__class__.enhanced_les_numerics(service, version, mode, path + ["enhanced_les_numerics"])
                self.fast_transient_settings = self.__class__.fast_transient_settings(service, version, mode, path + ["fast_transient_settings"])
                self.high_order_term_relaxation = self.__class__.high_order_term_relaxation(service, version, mode, path + ["high_order_term_relaxation"])
                self.high_speed_numerics = self.__class__.high_speed_numerics(service, version, mode, path + ["high_speed_numerics"])
                self.multiphase_numerics = self.__class__.multiphase_numerics(service, version, mode, path + ["multiphase_numerics"])
                self.nita_expert_controls = self.__class__.nita_expert_controls(service, version, mode, path + ["nita_expert_controls"])
                self.open_channel_wave_options = self.__class__.open_channel_wave_options(service, version, mode, path + ["open_channel_wave_options"])
                self.overset = self.__class__.overset(service, version, mode, path + ["overset"])
                self.poor_mesh_numerics = self.__class__.poor_mesh_numerics(service, version, mode, path + ["poor_mesh_numerics"])
                self.poor_mesh_robustness = self.__class__.poor_mesh_robustness(service, version, mode, path + ["poor_mesh_robustness"])
                self.previous_defaults = self.__class__.previous_defaults(service, version, mode, path + ["previous_defaults"])
                self.pseudo_time_method = self.__class__.pseudo_time_method(service, version, mode, path + ["pseudo_time_method"])
                self.slope_limiter_menu = self.__class__.slope_limiter_menu(service, version, mode, path + ["slope_limiter_menu"])
                self.stabilization_tools = self.__class__.stabilization_tools(service, version, mode, path + ["stabilization_tools"])
                self.transient_controls = self.__class__.transient_controls(service, version, mode, path + ["transient_controls"])
                self.warped_face_gradient_correction = self.__class__.warped_face_gradient_correction(service, version, mode, path + ["warped_face_gradient_correction"])
                self.zonal_pbns_solution_controls = self.__class__.zonal_pbns_solution_controls(service, version, mode, path + ["zonal_pbns_solution_controls"])
                self.accelerated_non_iterative_time_marching = self.__class__.accelerated_non_iterative_time_marching(service, version, mode, path + ["accelerated_non_iterative_time_marching"])
                self.adaptive_time_stepping = self.__class__.adaptive_time_stepping(service, version, mode, path + ["adaptive_time_stepping"])
                self.bc_pressure_extrapolations = self.__class__.bc_pressure_extrapolations(service, version, mode, path + ["bc_pressure_extrapolations"])
                self.cfl_based_adaptive_time_stepping = self.__class__.cfl_based_adaptive_time_stepping(service, version, mode, path + ["cfl_based_adaptive_time_stepping"])
                self.convergence_acceleration_for_stretched_meshes = self.__class__.convergence_acceleration_for_stretched_meshes(service, version, mode, path + ["convergence_acceleration_for_stretched_meshes"])
                self.correction_tolerance = self.__class__.correction_tolerance(service, version, mode, path + ["correction_tolerance"])
                self.coupled_vof_expert = self.__class__.coupled_vof_expert(service, version, mode, path + ["coupled_vof_expert"])
                self.courant_number = self.__class__.courant_number(service, version, mode, path + ["courant_number"])
                self.data_sampling = self.__class__.data_sampling(service, version, mode, path + ["data_sampling"])
                self.disable_reconstruction = self.__class__.disable_reconstruction(service, version, mode, path + ["disable_reconstruction"])
                self.discretization_scheme = self.__class__.discretization_scheme(service, version, mode, path + ["discretization_scheme"])
                self.enable_output_dp_dt = self.__class__.enable_output_dp_dt(service, version, mode, path + ["enable_output_dp_dt"])
                self.equation_ordering = self.__class__.equation_ordering(service, version, mode, path + ["equation_ordering"])
                self.equations = self.__class__.equations(service, version, mode, path + ["equations"])
                self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                self.flow_warnings = self.__class__.flow_warnings(service, version, mode, path + ["flow_warnings"])
                self.flux_type = self.__class__.flux_type(service, version, mode, path + ["flux_type"])
                self.gradient_scheme = self.__class__.gradient_scheme(service, version, mode, path + ["gradient_scheme"])
                self.heterogeneous_stiff_chemistry = self.__class__.heterogeneous_stiff_chemistry(service, version, mode, path + ["heterogeneous_stiff_chemistry"])
                self.limiter_warnings = self.__class__.limiter_warnings(service, version, mode, path + ["limiter_warnings"])
                self.limits = self.__class__.limits(service, version, mode, path + ["limits"])
                self.lock_solid_temperature = self.__class__.lock_solid_temperature(service, version, mode, path + ["lock_solid_temperature"])
                self.material_property_warnings = self.__class__.material_property_warnings(service, version, mode, path + ["material_property_warnings"])
                self.max_corrections = self.__class__.max_corrections(service, version, mode, path + ["max_corrections"])
                self.moving_mesh_numerics = self.__class__.moving_mesh_numerics(service, version, mode, path + ["moving_mesh_numerics"])
                self.mp_mfluid_aniso_drag = self.__class__.mp_mfluid_aniso_drag(service, version, mode, path + ["mp_mfluid_aniso_drag"])
                self.mp_reference_density = self.__class__.mp_reference_density(service, version, mode, path + ["mp_reference_density"])
                self.multi_grid_amg = self.__class__.multi_grid_amg(service, version, mode, path + ["multi_grid_amg"])
                self.multi_grid_controls = self.__class__.multi_grid_controls(service, version, mode, path + ["multi_grid_controls"])
                self.multi_grid_fas = self.__class__.multi_grid_fas(service, version, mode, path + ["multi_grid_fas"])
                self.multi_stage = self.__class__.multi_stage(service, version, mode, path + ["multi_stage"])
                self.nb_gradient_boundary_option = self.__class__.nb_gradient_boundary_option(service, version, mode, path + ["nb_gradient_boundary_option"])
                self.nb_gradient_improved_symmetry_periodic = self.__class__.nb_gradient_improved_symmetry_periodic(service, version, mode, path + ["nb_gradient_improved_symmetry_periodic"])
                self.number_of_iterations = self.__class__.number_of_iterations(service, version, mode, path + ["number_of_iterations"])
                self.numerical_beach_controls = self.__class__.numerical_beach_controls(service, version, mode, path + ["numerical_beach_controls"])
                self.numerics = self.__class__.numerics(service, version, mode, path + ["numerics"])
                self.open_channel_controls = self.__class__.open_channel_controls(service, version, mode, path + ["open_channel_controls"])
                self.p_v_controls = self.__class__.p_v_controls(service, version, mode, path + ["p_v_controls"])
                self.p_v_controls_advanced = self.__class__.p_v_controls_advanced(service, version, mode, path + ["p_v_controls_advanced"])
                self.p_v_coupling = self.__class__.p_v_coupling(service, version, mode, path + ["p_v_coupling"])
                self.phase_based_vof_discretization = self.__class__.phase_based_vof_discretization(service, version, mode, path + ["phase_based_vof_discretization"])
                self.pseudo_relaxation_factor = self.__class__.pseudo_relaxation_factor(service, version, mode, path + ["pseudo_relaxation_factor"])
                self.pseudo_transient = self.__class__.pseudo_transient(service, version, mode, path + ["pseudo_transient"])
                self.pseudo_transient_expert = self.__class__.pseudo_transient_expert(service, version, mode, path + ["pseudo_transient_expert"])
                self.reactions = self.__class__.reactions(service, version, mode, path + ["reactions"])
                self.reduced_rank_extrapolation = self.__class__.reduced_rank_extrapolation(service, version, mode, path + ["reduced_rank_extrapolation"])
                self.reduced_rank_extrapolation_options = self.__class__.reduced_rank_extrapolation_options(service, version, mode, path + ["reduced_rank_extrapolation_options"])
                self.relaxation_factor = self.__class__.relaxation_factor(service, version, mode, path + ["relaxation_factor"])
                self.relaxation_method = self.__class__.relaxation_method(service, version, mode, path + ["relaxation_method"])
                self.reporting_interval = self.__class__.reporting_interval(service, version, mode, path + ["reporting_interval"])
                self.residual_smoothing = self.__class__.residual_smoothing(service, version, mode, path + ["residual_smoothing"])
                self.residual_tolerance = self.__class__.residual_tolerance(service, version, mode, path + ["residual_tolerance"])
                self.residual_verbosity = self.__class__.residual_verbosity(service, version, mode, path + ["residual_verbosity"])
                self.second_order_time_options = self.__class__.second_order_time_options(service, version, mode, path + ["second_order_time_options"])
                self.set_all_species_together = self.__class__.set_all_species_together(service, version, mode, path + ["set_all_species_together"])
                self.set_controls_to_default = self.__class__.set_controls_to_default(service, version, mode, path + ["set_controls_to_default"])
                self.set_solution_methods_to_default = self.__class__.set_solution_methods_to_default(service, version, mode, path + ["set_solution_methods_to_default"])
                self.set_solution_steering = self.__class__.set_solution_steering(service, version, mode, path + ["set_solution_steering"])
                self.slope_limiter_set = self.__class__.slope_limiter_set(service, version, mode, path + ["slope_limiter_set"])
                self.solution_steering = self.__class__.solution_steering(service, version, mode, path + ["solution_steering"])
                self.stiff_chemistry = self.__class__.stiff_chemistry(service, version, mode, path + ["stiff_chemistry"])
                self.surface_tension = self.__class__.surface_tension(service, version, mode, path + ["surface_tension"])
                self.surface_tension_expert = self.__class__.surface_tension_expert(service, version, mode, path + ["surface_tension_expert"])
                self.time_step = self.__class__.time_step(service, version, mode, path + ["time_step"])
                self.under_relaxation = self.__class__.under_relaxation(service, version, mode, path + ["under_relaxation"])
                self.variable_time_stepping = self.__class__.variable_time_stepping(service, version, mode, path + ["variable_time_stepping"])
                self.vof_explicit_controls = self.__class__.vof_explicit_controls(service, version, mode, path + ["vof_explicit_controls"])
                self.vof_numerics = self.__class__.vof_numerics(service, version, mode, path + ["vof_numerics"])
                super().__init__(service, version, mode, path)
            class accelerated_non_iterative_time_marching(TUIMethod):
                """
                .
                """
            class adaptive_time_stepping(TUIMethod):
                """
                Set Error-based adaptive time-stepping parameters.
                """
            class bc_pressure_extrapolations(TUIMethod):
                """
                Setting pressure extrapolations schemes on boundaries.
                """
            class cfl_based_adaptive_time_stepping(TUIMethod):
                """
                Set CFL-based adaptive time-stepping parameters.
                """
            class convergence_acceleration_for_stretched_meshes(TUIMethod):
                """
                Enable convergence acceleration for stretched meshes to improve the convergence of the implicit density based solver on meshes with high cell stretching.
                """
            class correction_tolerance(TUIMethod):
                """
                Enter the correction tolerance menu.
                """
            class coupled_vof_expert(TUIMethod):
                """
                Set coupled vof expert controls.
                """
            class courant_number(TUIMethod):
                """
                .
                """
            class data_sampling(TUIMethod):
                """
                Set iteration options.
                """
            class disable_reconstruction(TUIMethod):
                """
                Enable/Disable reconstruction. When disabled, accuracy will be first-order.
                """
            class discretization_scheme(TUIMethod):
                """
                Enter the discretization-scheme menu.
                """
            class enable_output_dp_dt(TUIMethod):
                """
                Enable postprocessing of pressure time derivative. Requires storage of pressure from the previous timesteps.
                """
            class equation_ordering(TUIMethod):
                """
                Set the equation order.
                """
            class equations(TUIMethod):
                """
                Enter the equations menu.
                """
            class expert(TUIMethod):
                """
                Set expert options.
                """
            class flow_warnings(TUIMethod):
                """
                Control the display of warning diagnostics for boundaries with reversed flow, etc.
                """
            class flux_type(TUIMethod):
                """
                Enter the flux type.
                """
            class gradient_scheme(TUIMethod):
                """
                Set gradient options.
                """
            class heterogeneous_stiff_chemistry(TUIMethod):
                """
                Set heterogeneous stiff-chemistry solver.
                """
            class limiter_warnings(TUIMethod):
                """
                Control the display of limiter warning diagnostics.
                """
            class limits(TUIMethod):
                """
                .
                """
            class lock_solid_temperature(TUIMethod):
                """
                Lock the temperature for all solid and shell cell zones in the domain.
                """
            class material_property_warnings(TUIMethod):
                """
                Control the display of material property warning diagnostics:
                0 - off (no messages)
                1 - messages per material
                2 - messages per material and per property.
                """
            class max_corrections(TUIMethod):
                """
                Enter the max-corrections menu.
                """
            class moving_mesh_numerics(TUIMethod):
                """
                Transient options for sliding, moving, and/or dynamic mesh.
                """
            class mp_mfluid_aniso_drag(TUIMethod):
                """
                Set anisotropic drag parameters for Eulerian multiphase.
                """
            class mp_reference_density(TUIMethod):
                """
                Set reference density option for Eulerian multiphase.
                """
            class multi_grid_amg(TUIMethod):
                """
                Set the parameters that govern the algebraic multigrid procedure.
                """
            class multi_grid_controls(TUIMethod):
                """
                Enter the multi-grid-controls menu.
                """
            class multi_grid_fas(TUIMethod):
                """
                Set the coefficients that govern the FAS multigrid procedure.
                """
            class multi_stage(TUIMethod):
                """
                Set the multiple-stage time stepping scheme coefficients.
                """
            class nb_gradient_boundary_option(TUIMethod):
                """
                Set ggnb options.
                """
            class nb_gradient_improved_symmetry_periodic(TUIMethod):
                """
                Set improved ggnb symmetric/periodic boundary treatment.
                """
            class number_of_iterations(TUIMethod):
                """
                .
                """
            class numerical_beach_controls(TUIMethod):
                """
                Set damping function in flow direction.
                """
            class numerics(TUIMethod):
                """
                Set numeric options.
                """
            class open_channel_controls(TUIMethod):
                """
                Set additional open channel controls.
                """
            class p_v_controls(TUIMethod):
                """
                Set the pressure velocity coupling controls.
                """
            class p_v_controls_advanced(TUIMethod):
                """
                Set advanced pressure-velocity coupling controls.
                """
            class p_v_coupling(TUIMethod):
                """
                Select the pressure velocity coupling scheme.
                """
            class phase_based_vof_discretization(TUIMethod):
                """
                Set phase based slope limiter for VOF compressive scheme.
                """
            class pseudo_relaxation_factor(TUIMethod):
                """
                For backward compatibility, pseudo relaxation factor menu.
                """
            class pseudo_transient(TUIMethod):
                """
                For backward compatibility, pseudo transient (global time-step) formulation setup.
                """
            class pseudo_transient_expert(TUIMethod):
                """
                For backward compatibility, pseudo transient expert usage control.
                """
            class reactions(TUIMethod):
                """
                .
                """
            class reduced_rank_extrapolation(TUIMethod):
                """
                .
                """
            class reduced_rank_extrapolation_options(TUIMethod):
                """
                .
                """
            class relaxation_factor(TUIMethod):
                """
                Enter the relaxation-factor menu.
                """
            class relaxation_method(TUIMethod):
                """
                .
                """
            class reporting_interval(TUIMethod):
                """
                .
                """
            class residual_smoothing(TUIMethod):
                """
                .
                """
            class residual_tolerance(TUIMethod):
                """
                Enter the residual tolerance menu.
                """
            class residual_verbosity(TUIMethod):
                """
                .
                """
            class second_order_time_options(TUIMethod):
                """
                Set options for second-order time formulation.
                """
            class set_all_species_together(TUIMethod):
                """
                Set all species discretizations and URFs together.
                """
            class set_controls_to_default(TUIMethod):
                """
                Set controls to default values.
                """
            class set_solution_methods_to_default(TUIMethod):
                """
                Set solution methods to default values.
                """
            class set_solution_steering(TUIMethod):
                """
                Set Solution Steering Parameters.
                """
            class slope_limiter_set(TUIMethod):
                """
                Enter the slope limiter set menu.
                """
            class solution_steering(TUIMethod):
                """
                Enable solution steering for density-based solver.
                """
            class stiff_chemistry(TUIMethod):
                """
                Set solver options for stiff-chemistry solutions.
                """
            class surface_tension(TUIMethod):
                """
                Set surface-tension calculation options.
                """
            class surface_tension_expert(TUIMethod):
                """
                Set surface-tension expert options.
                """
            class time_step(TUIMethod):
                """
                .
                """
            class under_relaxation(TUIMethod):
                """
                Enter the under-relaxation menu.
                """
            class variable_time_stepping(TUIMethod):
                """
                Set Multiphase-Specific Adaptive time stepping parameters.
                """
            class vof_explicit_controls(TUIMethod):
                """
                Set Explicit VOF controls.
                """
            class vof_numerics(TUIMethod):
                """
                .
                """

            class acoustics_wave_equation_controls(TUIMenu):
                """
                Enter menu for acoustics wave equation solver controls.
                """
                def __init__(self, service, version, mode, path):
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.max_iterations_per_timestep = self.__class__.max_iterations_per_timestep(service, version, mode, path + ["max_iterations_per_timestep"])
                    self.relative_convergence_criterion = self.__class__.relative_convergence_criterion(service, version, mode, path + ["relative_convergence_criterion"])
                    super().__init__(service, version, mode, path)
                class max_iterations_per_timestep(TUIMethod):
                    """
                    .
                    """
                class relative_convergence_criterion(TUIMethod):
                    """
                    .
                    """

                class expert(TUIMenu):
                    """
                    Enter menu for expert controls.
                    """
                    def __init__(self, service, version, mode, path):
                        self.explicit_relaxation_factor = self.__class__.explicit_relaxation_factor(service, version, mode, path + ["explicit_relaxation_factor"])
                        self.under_relaxation_factor = self.__class__.under_relaxation_factor(service, version, mode, path + ["under_relaxation_factor"])
                        super().__init__(service, version, mode, path)
                    class explicit_relaxation_factor(TUIMethod):
                        """
                        .
                        """
                    class under_relaxation_factor(TUIMethod):
                        """
                        .
                        """

            class advanced(TUIMenu):
                """
                Enter the advanced settings menu.
                """
                def __init__(self, service, version, mode, path):
                    self.alternative_solver_defaults = self.__class__.alternative_solver_defaults(service, version, mode, path + ["alternative_solver_defaults"])
                    self.anisotropic_solid_heat_transfer = self.__class__.anisotropic_solid_heat_transfer(service, version, mode, path + ["anisotropic_solid_heat_transfer"])
                    self.continuity_transient_term_linearization = self.__class__.continuity_transient_term_linearization(service, version, mode, path + ["continuity_transient_term_linearization"])
                    self.non_reflecting_boundary_treatment = self.__class__.non_reflecting_boundary_treatment(service, version, mode, path + ["non_reflecting_boundary_treatment"])
                    self.secondary_gradient_limiting = self.__class__.secondary_gradient_limiting(service, version, mode, path + ["secondary_gradient_limiting"])
                    self.turbomachinery_specific_numerics = self.__class__.turbomachinery_specific_numerics(service, version, mode, path + ["turbomachinery_specific_numerics"])
                    self.alternate_wall_temp_formulation = self.__class__.alternate_wall_temp_formulation(service, version, mode, path + ["alternate_wall_temp_formulation"])
                    self.alternative_wall_discretization = self.__class__.alternative_wall_discretization(service, version, mode, path + ["alternative_wall_discretization"])
                    self.anisotropic_heat_flux = self.__class__.anisotropic_heat_flux(service, version, mode, path + ["anisotropic_heat_flux"])
                    self.bcd_boundedness = self.__class__.bcd_boundedness(service, version, mode, path + ["bcd_boundedness"])
                    self.bcd_scheme_type = self.__class__.bcd_scheme_type(service, version, mode, path + ["bcd_scheme_type"])
                    self.bcd_weights_freeze = self.__class__.bcd_weights_freeze(service, version, mode, path + ["bcd_weights_freeze"])
                    self.correction_form = self.__class__.correction_form(service, version, mode, path + ["correction_form"])
                    self.energy_numerical_noise_filter = self.__class__.energy_numerical_noise_filter(service, version, mode, path + ["energy_numerical_noise_filter"])
                    self.energy_reconstruction_gradient_limiting = self.__class__.energy_reconstruction_gradient_limiting(service, version, mode, path + ["energy_reconstruction_gradient_limiting"])
                    self.enthalpy_reference_temperature = self.__class__.enthalpy_reference_temperature(service, version, mode, path + ["enthalpy_reference_temperature"])
                    self.explicit_under_relaxation_value = self.__class__.explicit_under_relaxation_value(service, version, mode, path + ["explicit_under_relaxation_value"])
                    self.linearized_mass_transfer_udf = self.__class__.linearized_mass_transfer_udf(service, version, mode, path + ["linearized_mass_transfer_udf"])
                    self.nci_secondary_gradient_correction = self.__class__.nci_secondary_gradient_correction(service, version, mode, path + ["nci_secondary_gradient_correction"])
                    self.retain_cell_residuals = self.__class__.retain_cell_residuals(service, version, mode, path + ["retain_cell_residuals"])
                    self.retain_temporary_solver_mem = self.__class__.retain_temporary_solver_mem(service, version, mode, path + ["retain_temporary_solver_mem"])
                    self.show_all_discretization_schemes = self.__class__.show_all_discretization_schemes(service, version, mode, path + ["show_all_discretization_schemes"])
                    self.singhal_et_al_cavitation_model = self.__class__.singhal_et_al_cavitation_model(service, version, mode, path + ["singhal_et_al_cavitation_model"])
                    self.skewness_correction_enhanced = self.__class__.skewness_correction_enhanced(service, version, mode, path + ["skewness_correction_enhanced"])
                    self.transient_frame_motion_numerics = self.__class__.transient_frame_motion_numerics(service, version, mode, path + ["transient_frame_motion_numerics"])
                    self.volume_flux_for_single_phase = self.__class__.volume_flux_for_single_phase(service, version, mode, path + ["volume_flux_for_single_phase"])
                    super().__init__(service, version, mode, path)
                class alternate_wall_temp_formulation(TUIMethod):
                    """
                    Alternate formulation for wall temperatures?.
                    """
                class alternative_wall_discretization(TUIMethod):
                    """
                    Enable alternative wall discretization.
                    """
                class anisotropic_heat_flux(TUIMethod):
                    """
                    Select the heat flux calculation methods.
                    """
                class bcd_boundedness(TUIMethod):
                    """
                    .
                    """
                class bcd_scheme_type(TUIMethod):
                    """
                    BCD scheme type (standard or tunable).
                    """
                class bcd_weights_freeze(TUIMethod):
                    """
                    At each timestep, freeze BCD scheme weights after specified iteration
                    in order to improve timestep convergence.
                    """
                class correction_form(TUIMethod):
                    """
                    Discretize momentum equations in correction form for the pressure-based solver.
                    """
                class energy_numerical_noise_filter(TUIMethod):
                    """
                    The energy equation numerical noise filter can be enabled to eliminate non-physical numerical noise in the energy field.
                    The numerical noise can appear in solution fields where large variations in specific heat or combustion with phase change are present.
                    Using the energy equation numerical noise filter increases robustness, but may make the solution slightly more diffusive.
                    """
                class energy_reconstruction_gradient_limiting(TUIMethod):
                    """
                    Enable limiting of reconstruction gradient for the energy equation.
                    """
                class enthalpy_reference_temperature(TUIMethod):
                    """
                    .
                    """
                class explicit_under_relaxation_value(TUIMethod):
                    """
                    .
                    """
                class linearized_mass_transfer_udf(TUIMethod):
                    """
                    Use linearized mass transfer UDFs?.
                    """
                class nci_secondary_gradient_correction(TUIMethod):
                    """
                    Enter secondary gradient source menu for non-conformal interfaces.
                    """
                class retain_cell_residuals(TUIMethod):
                    """
                    Retain cell residuals for postprocessing?.
                    """
                class retain_temporary_solver_mem(TUIMethod):
                    """
                    Retain temporary solver memory?.
                    """
                class show_all_discretization_schemes(TUIMethod):
                    """
                    Allow selection of all applicable discretization schemes?.
                    """
                class singhal_et_al_cavitation_model(TUIMethod):
                    """
                    Use Singhal-et-al cavitation model?.
                    """
                class skewness_correction_enhanced(TUIMethod):
                    """
                    Enable enhanced skewness correction scheme.
                    """
                class transient_frame_motion_numerics(TUIMethod):
                    """
                    Enable time-step independent continuity discretization for transient cases with frame motion.
                    """
                class volume_flux_for_single_phase(TUIMethod):
                    """
                    Enable/disable volume flux formulation for single phase flows.
                    """

                class alternative_solver_defaults(TUIMenu):
                    """
                    Enter alternative solver defaults menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.option = self.__class__.option(service, version, mode, path + ["option"])
                        super().__init__(service, version, mode, path)
                    class option(TUIMethod):
                        """
                        Select solver defaults option to modify general numerics settings.
                        """

                class anisotropic_solid_heat_transfer(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.flux = self.__class__.flux(service, version, mode, path + ["flux"])
                        self.gradient = self.__class__.gradient(service, version, mode, path + ["gradient"])
                        self.relaxation = self.__class__.relaxation(service, version, mode, path + ["relaxation"])
                        super().__init__(service, version, mode, path)
                    class flux(TUIMethod):
                        """
                        .
                        """
                    class gradient(TUIMethod):
                        """
                        .
                        """
                    class relaxation(TUIMethod):
                        """
                        .
                        """

                class continuity_transient_term_linearization(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.linearize = self.__class__.linearize(service, version, mode, path + ["linearize"])
                        self.threshold = self.__class__.threshold(service, version, mode, path + ["threshold"])
                        super().__init__(service, version, mode, path)
                    class linearize(TUIMethod):
                        """
                        .
                        """
                    class threshold(TUIMethod):
                        """
                        .
                        """

                class non_reflecting_boundary_treatment(TUIMenu):
                    """
                    Enter non reflecting boundary treatment using minimal pressure reflection approach menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.pressure_inlet = self.__class__.pressure_inlet(service, version, mode, path + ["pressure_inlet"])
                        self.pressure_outlet = self.__class__.pressure_outlet(service, version, mode, path + ["pressure_outlet"])
                        self.velocity_inlet = self.__class__.velocity_inlet(service, version, mode, path + ["velocity_inlet"])
                        super().__init__(service, version, mode, path)
                    class pressure_inlet(TUIMethod):
                        """
                        Enabling the use of minimal pressure reflection treatment. This treatment will minimize pressure wave reflections from the boundaries on which this option is active, but not necessarily fully eliminating them. The reflections would be of an acceptable limit in order to not contaminate the solution, the simulation will gain from the robustness of the new algorithm compared to traditional non-reflecting boundary condition treatment.
                        """
                    class pressure_outlet(TUIMethod):
                        """
                        Enabling the use of minimal pressure reflection treatment. This treatment will minimize pressure wave reflections from the boundaries on which this option is active, but not necessarily fully eliminating them. The reflections would be of an acceptable limit in order to not contaminate the solution, the simulation will gain from the robustness of the new algorithm compared to traditional non-reflecting boundary condition treatment.
                        """
                    class velocity_inlet(TUIMethod):
                        """
                        Enabling the use of minimal pressure reflection treatment. This treatment will minimize pressure wave reflections from the boundaries on which this option is active, but not necessarily fully eliminating them. The reflections would be of an acceptable limit in order to not contaminate the solution, the simulation will gain from the robustness of the new algorithm compared to traditional non-reflecting boundary condition treatment.
                        """

                class secondary_gradient_limiting(TUIMenu):
                    """
                    Enter the Secondary Gradient Limiting Menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.energy = self.__class__.energy(service, version, mode, path + ["energy"])
                        self.mesh_quality_limits = self.__class__.mesh_quality_limits(service, version, mode, path + ["mesh_quality_limits"])
                        self.uds = self.__class__.uds(service, version, mode, path + ["uds"])
                        super().__init__(service, version, mode, path)
                    class energy(TUIMethod):
                        """
                        Enable/disable secondary gradient limiting at coupled walls for energy equation.
                        """
                    class mesh_quality_limits(TUIMethod):
                        """
                        Specify minimum and maximum mesh quality limits.
                        """
                    class uds(TUIMethod):
                        """
                        Enable/disable secondary gradient limiting at coupled walls for user-defined scalars.
                        """

                class turbomachinery_specific_numerics(TUIMenu):
                    """
                    Enter turbomachinery-specific numerics menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.options = self.__class__.options(service, version, mode, path + ["options"])
                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                        super().__init__(service, version, mode, path)
                    class enable(TUIMethod):
                        """
                        Activate/deactivate turbomachinery-specific numerics.
                        """

                    class options(TUIMenu):
                        """
                        Enter turbomachinery-specific numerics options menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.gradient_limiter_combination = self.__class__.gradient_limiter_combination(service, version, mode, path + ["gradient_limiter_combination"])
                            self.pseudo_time_scale_type = self.__class__.pseudo_time_scale_type(service, version, mode, path + ["pseudo_time_scale_type"])
                            super().__init__(service, version, mode, path)
                        class gradient_limiter_combination(TUIMethod):
                            """
                            Select gradient limiter combination for turbomachinery-specific numerics.
                            """
                        class pseudo_time_scale_type(TUIMethod):
                            """
                            Select pseudo transient time scale type for turbomachinery-specific numerics.
                            """

            class amg_options(TUIMenu):
                """
                Enter AMG options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.aggressive_amg_coarsening = self.__class__.aggressive_amg_coarsening(service, version, mode, path + ["aggressive_amg_coarsening"])
                    self.amg_gpgpu_options = self.__class__.amg_gpgpu_options(service, version, mode, path + ["amg_gpgpu_options"])
                    self.conservative_amg_coarsening = self.__class__.conservative_amg_coarsening(service, version, mode, path + ["conservative_amg_coarsening"])
                    self.laplace_coarsening = self.__class__.laplace_coarsening(service, version, mode, path + ["laplace_coarsening"])
                    super().__init__(service, version, mode, path)
                class aggressive_amg_coarsening(TUIMethod):
                    """
                    Use aggressive AMG coarsening.
                    """
                class amg_gpgpu_options(TUIMethod):
                    """
                    Set GPGPU AMG solver options.
                    """
                class conservative_amg_coarsening(TUIMethod):
                    """
                    Use conservative AMG coarsening?.
                    """
                class laplace_coarsening(TUIMethod):
                    """
                    Set AMG laplace coarsening options.
                    """

            class axisymmetric(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.axis_stabilization = self.__class__.axis_stabilization(service, version, mode, path + ["axis_stabilization"])
                    super().__init__(service, version, mode, path)
                class axis_stabilization(TUIMethod):
                    """
                    .
                    """

            class contact_solution_controls(TUIMenu):
                """
                Solver controls for contact marks method.
                """
                def __init__(self, service, version, mode, path):
                    self.amg = self.__class__.amg(service, version, mode, path + ["amg"])
                    self.methods = self.__class__.methods(service, version, mode, path + ["methods"])
                    self.miscellaneous = self.__class__.miscellaneous(service, version, mode, path + ["miscellaneous"])
                    self.models = self.__class__.models(service, version, mode, path + ["models"])
                    self.parameters = self.__class__.parameters(service, version, mode, path + ["parameters"])
                    self.spatial = self.__class__.spatial(service, version, mode, path + ["spatial"])
                    self.transient = self.__class__.transient(service, version, mode, path + ["transient"])
                    self.set_settings_to_default = self.__class__.set_settings_to_default(service, version, mode, path + ["set_settings_to_default"])
                    self.solution_stabilization = self.__class__.solution_stabilization(service, version, mode, path + ["solution_stabilization"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class set_settings_to_default(TUIMethod):
                    """
                    Set contact solution stabilization to default.
                    """
                class solution_stabilization(TUIMethod):
                    """
                    .
                    """
                class verbosity(TUIMethod):
                    """
                    .
                    """

                class amg(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.coarsen_rate = self.__class__.coarsen_rate(service, version, mode, path + ["coarsen_rate"])
                        self.enforce_laplace_coarsening = self.__class__.enforce_laplace_coarsening(service, version, mode, path + ["enforce_laplace_coarsening"])
                        self.increase_pre_sweeps = self.__class__.increase_pre_sweeps(service, version, mode, path + ["increase_pre_sweeps"])
                        self.pre_sweeps = self.__class__.pre_sweeps(service, version, mode, path + ["pre_sweeps"])
                        self.specify_coarsening_rate = self.__class__.specify_coarsening_rate(service, version, mode, path + ["specify_coarsening_rate"])
                        super().__init__(service, version, mode, path)
                    class coarsen_rate(TUIMethod):
                        """
                        .
                        """
                    class enforce_laplace_coarsening(TUIMethod):
                        """
                        .
                        """
                    class increase_pre_sweeps(TUIMethod):
                        """
                        .
                        """
                    class pre_sweeps(TUIMethod):
                        """
                        .
                        """
                    class specify_coarsening_rate(TUIMethod):
                        """
                        .
                        """

                class methods(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.gradient_controls = self.__class__.gradient_controls(service, version, mode, path + ["gradient_controls"])
                        self.pressure_velocity_coupling_controls = self.__class__.pressure_velocity_coupling_controls(service, version, mode, path + ["pressure_velocity_coupling_controls"])
                        self.pressure_velocity_coupling_method = self.__class__.pressure_velocity_coupling_method(service, version, mode, path + ["pressure_velocity_coupling_method"])
                        self.specify_gradient_method = self.__class__.specify_gradient_method(service, version, mode, path + ["specify_gradient_method"])
                        super().__init__(service, version, mode, path)
                    class gradient_controls(TUIMethod):
                        """
                        .
                        """
                    class pressure_velocity_coupling_controls(TUIMethod):
                        """
                        .
                        """
                    class pressure_velocity_coupling_method(TUIMethod):
                        """
                        .
                        """
                    class specify_gradient_method(TUIMethod):
                        """
                        .
                        """

                class miscellaneous(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.compute_statistics = self.__class__.compute_statistics(service, version, mode, path + ["compute_statistics"])
                        self.statistics_level = self.__class__.statistics_level(service, version, mode, path + ["statistics_level"])
                        super().__init__(service, version, mode, path)
                    class compute_statistics(TUIMethod):
                        """
                        .
                        """
                    class statistics_level(TUIMethod):
                        """
                        .
                        """

                class models(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.model_ramping = self.__class__.model_ramping(service, version, mode, path + ["model_ramping"])
                        self.ramp_flow = self.__class__.ramp_flow(service, version, mode, path + ["ramp_flow"])
                        self.ramp_scalars = self.__class__.ramp_scalars(service, version, mode, path + ["ramp_scalars"])
                        self.ramp_turbulence = self.__class__.ramp_turbulence(service, version, mode, path + ["ramp_turbulence"])
                        super().__init__(service, version, mode, path)
                    class model_ramping(TUIMethod):
                        """
                        .
                        """
                    class ramp_flow(TUIMethod):
                        """
                        .
                        """
                    class ramp_scalars(TUIMethod):
                        """
                        .
                        """
                    class ramp_turbulence(TUIMethod):
                        """
                        .
                        """

                class parameters(TUIMenu):
                    """
                    Parameters used in stabilization strategy.
                    """
                    def __init__(self, service, version, mode, path):
                        self.extrapolation_method = self.__class__.extrapolation_method(service, version, mode, path + ["extrapolation_method"])
                        self.iterations = self.__class__.iterations(service, version, mode, path + ["iterations"])
                        self.persistence_fixed_duration = self.__class__.persistence_fixed_duration(service, version, mode, path + ["persistence_fixed_duration"])
                        self.persistence_fixed_time_steps = self.__class__.persistence_fixed_time_steps(service, version, mode, path + ["persistence_fixed_time_steps"])
                        self.solution_stabilization_persistence = self.__class__.solution_stabilization_persistence(service, version, mode, path + ["solution_stabilization_persistence"])
                        super().__init__(service, version, mode, path)
                    class extrapolation_method(TUIMethod):
                        """
                        Solution extrapolation method for cells changing status from contact to non-contact [0-none, 1-local extrapolation].
                        """
                    class iterations(TUIMethod):
                        """
                        .
                        """
                    class persistence_fixed_duration(TUIMethod):
                        """
                        .
                        """
                    class persistence_fixed_time_steps(TUIMethod):
                        """
                        .
                        """
                    class solution_stabilization_persistence(TUIMethod):
                        """
                        .
                        """

                class spatial(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.first_to_second_order_blending = self.__class__.first_to_second_order_blending(service, version, mode, path + ["first_to_second_order_blending"])
                        self.first_to_second_order_blending_list = self.__class__.first_to_second_order_blending_list(service, version, mode, path + ["first_to_second_order_blending_list"])
                        self.flow_skew_diffusion_exclude = self.__class__.flow_skew_diffusion_exclude(service, version, mode, path + ["flow_skew_diffusion_exclude"])
                        self.rhie_chow_flux_specify = self.__class__.rhie_chow_flux_specify(service, version, mode, path + ["rhie_chow_flux_specify"])
                        self.rhie_chow_method = self.__class__.rhie_chow_method(service, version, mode, path + ["rhie_chow_method"])
                        self.scalars_skew_diffusion_exclude = self.__class__.scalars_skew_diffusion_exclude(service, version, mode, path + ["scalars_skew_diffusion_exclude"])
                        self.scheme = self.__class__.scheme(service, version, mode, path + ["scheme"])
                        super().__init__(service, version, mode, path)
                    class first_to_second_order_blending(TUIMethod):
                        """
                        .
                        """
                    class first_to_second_order_blending_list(TUIMethod):
                        """
                        .
                        """
                    class flow_skew_diffusion_exclude(TUIMethod):
                        """
                        .
                        """
                    class rhie_chow_flux_specify(TUIMethod):
                        """
                        .
                        """
                    class rhie_chow_method(TUIMethod):
                        """
                        .
                        """
                    class scalars_skew_diffusion_exclude(TUIMethod):
                        """
                        .
                        """
                    class scheme(TUIMethod):
                        """
                        .
                        """

                class transient(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.time_scale_modification_factor = self.__class__.time_scale_modification_factor(service, version, mode, path + ["time_scale_modification_factor"])
                        self.time_scale_modification_method = self.__class__.time_scale_modification_method(service, version, mode, path + ["time_scale_modification_method"])
                        self.transient_parameters_specify = self.__class__.transient_parameters_specify(service, version, mode, path + ["transient_parameters_specify"])
                        self.transient_scheme = self.__class__.transient_scheme(service, version, mode, path + ["transient_scheme"])
                        super().__init__(service, version, mode, path)
                    class time_scale_modification_factor(TUIMethod):
                        """
                        .
                        """
                    class time_scale_modification_method(TUIMethod):
                        """
                        .
                        """
                    class transient_parameters_specify(TUIMethod):
                        """
                        .
                        """
                    class transient_scheme(TUIMethod):
                        """
                        .
                        """

            class data_sampling_options(TUIMenu):
                """
                Data sampling options for statistics.
                """
                def __init__(self, service, version, mode, path):
                    self.dft_datasets = self.__class__.dft_datasets(service, version, mode, path + ["dft_datasets"])
                    self.add_datasets = self.__class__.add_datasets(service, version, mode, path + ["add_datasets"])
                    self.list_datasets = self.__class__.list_datasets(service, version, mode, path + ["list_datasets"])
                    self.remove_dataset = self.__class__.remove_dataset(service, version, mode, path + ["remove_dataset"])
                    super().__init__(service, version, mode, path)
                class add_datasets(TUIMethod):
                    """
                    Add a dataset. After providing the zones for a dataset, press [Enter] to move onto selecting quantities. Enter () to complete the quantity selection for this dataset.
                    """
                class list_datasets(TUIMethod):
                    """
                    .
                    """
                class remove_dataset(TUIMethod):
                    """
                    Remove dataset.
                    """

                class dft_datasets(TUIMenu):
                    """
                    Data sampling options for runtime discrete Fourier transform.
                    """
                    def __init__(self, service, version, mode, path):
                        self.add_band_datasets = self.__class__.add_band_datasets(service, version, mode, path + ["add_band_datasets"])
                        self.add_tone_datasets = self.__class__.add_tone_datasets(service, version, mode, path + ["add_tone_datasets"])
                        self.dataset_properties = self.__class__.dataset_properties(service, version, mode, path + ["dataset_properties"])
                        self.delete_dataset = self.__class__.delete_dataset(service, version, mode, path + ["delete_dataset"])
                        self.list_datasets = self.__class__.list_datasets(service, version, mode, path + ["list_datasets"])
                        self.quantities = self.__class__.quantities(service, version, mode, path + ["quantities"])
                        self.window_function = self.__class__.window_function(service, version, mode, path + ["window_function"])
                        self.zones = self.__class__.zones(service, version, mode, path + ["zones"])
                        super().__init__(service, version, mode, path)
                    class add_band_datasets(TUIMethod):
                        """
                        Add DFT datasets for a frequency band.
                        """
                    class add_tone_datasets(TUIMethod):
                        """
                        Add DFT datasets for a single tone.
                        """
                    class dataset_properties(TUIMethod):
                        """
                        Print properties of a DFT dataset.
                        """
                    class delete_dataset(TUIMethod):
                        """
                        Delete DFT datasets.
                        """
                    class list_datasets(TUIMethod):
                        """
                        List DFT datasets.
                        """
                    class quantities(TUIMethod):
                        """
                        Select quantities for a new DFT dataset. Enter () to complete the quantity selection.
                        """
                    class window_function(TUIMethod):
                        """
                        Select window function for a DFT dataset.
                        """
                    class zones(TUIMethod):
                        """
                        Select zones for a new DFT dataset.
                        """

            class divergence_prevention(TUIMenu):
                """
                Enter the divergence prevention menu.
                """
                def __init__(self, service, version, mode, path):
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    Enable divergence prevention.
                    """

            class enhanced_les_numerics(TUIMenu):
                """
                Enter enhanced LES options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.optimized_advection = self.__class__.optimized_advection(service, version, mode, path + ["optimized_advection"])
                    self.optimized_algorithm = self.__class__.optimized_algorithm(service, version, mode, path + ["optimized_algorithm"])
                    self.optimized_cd = self.__class__.optimized_cd(service, version, mode, path + ["optimized_cd"])
                    self.optimized_les_numerics = self.__class__.optimized_les_numerics(service, version, mode, path + ["optimized_les_numerics"])
                    super().__init__(service, version, mode, path)
                class optimized_advection(TUIMethod):
                    """
                    Use advection scheme optimized for LES.
                    """
                class optimized_algorithm(TUIMethod):
                    """
                    Use solver algorithm optimized for LES.
                    """
                class optimized_cd(TUIMethod):
                    """
                    Use optimized central difference discretization.
                    """
                class optimized_les_numerics(TUIMethod):
                    """
                    Use optimized LES numerics.
                    """

            class fast_transient_settings(TUIMenu):
                """
                Enter the fast transient settings menu.
                """
                def __init__(self, service, version, mode, path):
                    self.rk2 = self.__class__.rk2(service, version, mode, path + ["rk2"])
                    self.update_stage_gradients = self.__class__.update_stage_gradients(service, version, mode, path + ["update_stage_gradients"])
                    super().__init__(service, version, mode, path)
                class rk2(TUIMethod):
                    """
                    .
                    """
                class update_stage_gradients(TUIMethod):
                    """
                    .
                    """

            class high_order_term_relaxation(TUIMenu):
                """
                Enter High Order Relaxation Menu.
                """
                def __init__(self, service, version, mode, path):
                    self.options = self.__class__.options(service, version, mode, path + ["options"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    .
                    """

                class options(TUIMenu):
                    """
                    High Order Term Relaxation Options.
                    """
                    def __init__(self, service, version, mode, path):
                        self.variables = self.__class__.variables(service, version, mode, path + ["variables"])
                        self.relaxation_factor = self.__class__.relaxation_factor(service, version, mode, path + ["relaxation_factor"])
                        self.type = self.__class__.type(service, version, mode, path + ["type"])
                        super().__init__(service, version, mode, path)
                    class relaxation_factor(TUIMethod):
                        """
                        .
                        """
                    class type(TUIMethod):
                        """
                        Enter high order relaxation type.
                        """

                    class variables(TUIMenu):
                        """
                        Select Variables.
                        """
                        def __init__(self, service, version, mode, path):
                            self.select = self.__class__.select(service, version, mode, path + ["select"])
                            super().__init__(service, version, mode, path)
                        class select(TUIMethod):
                            """
                            Select variables for high order term relaxation.
                            """

            class high_speed_numerics(TUIMenu):
                """
                Enter high-speed-numerics menu.
                """
                def __init__(self, service, version, mode, path):
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.visualize_pressure_discontinuity_sensor = self.__class__.visualize_pressure_discontinuity_sensor(service, version, mode, path + ["visualize_pressure_discontinuity_sensor"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    .
                    """
                class expert(TUIMethod):
                    """
                    Expert high-speed-numerics.
                    """
                class visualize_pressure_discontinuity_sensor(TUIMethod):
                    """
                    .
                    """

            class multiphase_numerics(TUIMenu):
                """
                Enter the multiphase numerics options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.advanced_stability_controls = self.__class__.advanced_stability_controls(service, version, mode, path + ["advanced_stability_controls"])
                    self.boiling_parameters = self.__class__.boiling_parameters(service, version, mode, path + ["boiling_parameters"])
                    self.compressible_flow = self.__class__.compressible_flow(service, version, mode, path + ["compressible_flow"])
                    self.default_controls = self.__class__.default_controls(service, version, mode, path + ["default_controls"])
                    self.energy = self.__class__.energy(service, version, mode, path + ["energy"])
                    self.face_pressure_controls = self.__class__.face_pressure_controls(service, version, mode, path + ["face_pressure_controls"])
                    self.heat_mass_transfer = self.__class__.heat_mass_transfer(service, version, mode, path + ["heat_mass_transfer"])
                    self.interphase_interactions = self.__class__.interphase_interactions(service, version, mode, path + ["interphase_interactions"])
                    self.porous_media = self.__class__.porous_media(service, version, mode, path + ["porous_media"])
                    self.solution_stabilization = self.__class__.solution_stabilization(service, version, mode, path + ["solution_stabilization"])
                    self.viscous_flow = self.__class__.viscous_flow(service, version, mode, path + ["viscous_flow"])
                    self.stable_vof_settings = self.__class__.stable_vof_settings(service, version, mode, path + ["stable_vof_settings"])
                    super().__init__(service, version, mode, path)
                class stable_vof_settings(TUIMethod):
                    """
                    Execute Stable VOF settings.
                    """

                class advanced_stability_controls(TUIMenu):
                    """
                    Stability controls for multiphase flow.
                    """
                    def __init__(self, service, version, mode, path):
                        self.anti_diffusion = self.__class__.anti_diffusion(service, version, mode, path + ["anti_diffusion"])
                        self.equation_order = self.__class__.equation_order(service, version, mode, path + ["equation_order"])
                        self.hybrid_nita = self.__class__.hybrid_nita(service, version, mode, path + ["hybrid_nita"])
                        self.num_ventilation = self.__class__.num_ventilation(service, version, mode, path + ["num_ventilation"])
                        self.p_v_coupling = self.__class__.p_v_coupling(service, version, mode, path + ["p_v_coupling"])
                        self.pseudo_time = self.__class__.pseudo_time(service, version, mode, path + ["pseudo_time"])
                        self.pseudo_transient = self.__class__.pseudo_transient(service, version, mode, path + ["pseudo_transient"])
                        self.velocity_limiting = self.__class__.velocity_limiting(service, version, mode, path + ["velocity_limiting"])
                        super().__init__(service, version, mode, path)

                    class anti_diffusion(TUIMenu):
                        """
                        Anti Diffusion Menu for VOF/Multi-Fluid VOF Models.
                        """
                        def __init__(self, service, version, mode, path):
                            self.enable_dynamic_strength = self.__class__.enable_dynamic_strength(service, version, mode, path + ["enable_dynamic_strength"])
                            self.set_dynamic_strength_exponent = self.__class__.set_dynamic_strength_exponent(service, version, mode, path + ["set_dynamic_strength_exponent"])
                            self.set_maximum_dynamic_strength = self.__class__.set_maximum_dynamic_strength(service, version, mode, path + ["set_maximum_dynamic_strength"])
                            super().__init__(service, version, mode, path)
                        class enable_dynamic_strength(TUIMethod):
                            """
                            .
                            """
                        class set_dynamic_strength_exponent(TUIMethod):
                            """
                            .
                            """
                        class set_maximum_dynamic_strength(TUIMethod):
                            """
                            .
                            """

                    class equation_order(TUIMenu):
                        """
                        Equation Order Menu for Homogeneous Multiphase Flow Models.
                        """
                        def __init__(self, service, version, mode, path):
                            self.solve_exp_vof_at_end = self.__class__.solve_exp_vof_at_end(service, version, mode, path + ["solve_exp_vof_at_end"])
                            self.solve_flow_last = self.__class__.solve_flow_last(service, version, mode, path + ["solve_flow_last"])
                            super().__init__(service, version, mode, path)
                        class solve_exp_vof_at_end(TUIMethod):
                            """
                            .
                            """
                        class solve_flow_last(TUIMethod):
                            """
                            .
                            """

                    class hybrid_nita(TUIMenu):
                        """
                        Hybrid NITA stability controls for multiphase flow.
                        """
                        def __init__(self, service, version, mode, path):
                            self.instability_detector = self.__class__.instability_detector(service, version, mode, path + ["instability_detector"])
                            self.initial_outer_iterations = self.__class__.initial_outer_iterations(service, version, mode, path + ["initial_outer_iterations"])
                            self.outer_iterations = self.__class__.outer_iterations(service, version, mode, path + ["outer_iterations"])
                            super().__init__(service, version, mode, path)
                        class initial_outer_iterations(TUIMethod):
                            """
                            .
                            """
                        class outer_iterations(TUIMethod):
                            """
                            .
                            """

                        class instability_detector(TUIMenu):
                            """
                            Set Hybrid NITA instability detector controls.
                            """
                            def __init__(self, service, version, mode, path):
                                self.enable_instability_detector = self.__class__.enable_instability_detector(service, version, mode, path + ["enable_instability_detector"])
                                self.set_cfl_limit = self.__class__.set_cfl_limit(service, version, mode, path + ["set_cfl_limit"])
                                self.set_cfl_type = self.__class__.set_cfl_type(service, version, mode, path + ["set_cfl_type"])
                                self.set_velocity_limit = self.__class__.set_velocity_limit(service, version, mode, path + ["set_velocity_limit"])
                                self.unstable_event_outer_iterations = self.__class__.unstable_event_outer_iterations(service, version, mode, path + ["unstable_event_outer_iterations"])
                                super().__init__(service, version, mode, path)
                            class enable_instability_detector(TUIMethod):
                                """
                                .
                                """
                            class set_cfl_limit(TUIMethod):
                                """
                                .
                                """
                            class set_cfl_type(TUIMethod):
                                """
                                Set Courant Number type for detection of unstable event.
                                """
                            class set_velocity_limit(TUIMethod):
                                """
                                .
                                """
                            class unstable_event_outer_iterations(TUIMethod):
                                """
                                .
                                """

                    class num_ventilation(TUIMenu):
                        """
                        Numerical Ventilation Menu for VOF Model.
                        """
                        def __init__(self, service, version, mode, path):
                            self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                            self.near_wall_treatment_options = self.__class__.near_wall_treatment_options(service, version, mode, path + ["near_wall_treatment_options"])
                            self.tau_estimation_options = self.__class__.tau_estimation_options(service, version, mode, path + ["tau_estimation_options"])
                            self.trapped_phase_vof_max = self.__class__.trapped_phase_vof_max(service, version, mode, path + ["trapped_phase_vof_max"])
                            self.trapped_phase_vof_min = self.__class__.trapped_phase_vof_min(service, version, mode, path + ["trapped_phase_vof_min"])
                            super().__init__(service, version, mode, path)
                        class enable(TUIMethod):
                            """
                            Enable numerical ventilation treatment to remove trapped phase adjacent to wall.
                            """
                        class near_wall_treatment_options(TUIMethod):
                            """
                            Set near wall treatment options.
                            """
                        class tau_estimation_options(TUIMethod):
                            """
                            Set time step size option for numerical ventilation treatment.
                            """
                        class trapped_phase_vof_max(TUIMethod):
                            """
                            Set trapped phase maximum volume fraction to activate numerical ventilation treatment for non-trapped phases.
                            """
                        class trapped_phase_vof_min(TUIMethod):
                            """
                            Set trapped phase minimum volume fraction to activate numerical ventilation treatment for trapped phase.
                            """

                    class p_v_coupling(TUIMenu):
                        """
                        Pressure velocity coupling controls for multiphase flow.
                        """
                        def __init__(self, service, version, mode, path):
                            self.coupled_vof = self.__class__.coupled_vof(service, version, mode, path + ["coupled_vof"])
                            self.pressure_interpolation = self.__class__.pressure_interpolation(service, version, mode, path + ["pressure_interpolation"])
                            self.rhie_chow_flux = self.__class__.rhie_chow_flux(service, version, mode, path + ["rhie_chow_flux"])
                            self.skewness_correction = self.__class__.skewness_correction(service, version, mode, path + ["skewness_correction"])
                            super().__init__(service, version, mode, path)

                        class coupled_vof(TUIMenu):
                            """
                            Set Coupled VOF stability controls.
                            """
                            def __init__(self, service, version, mode, path):
                                self.buoyancy_force_linearization = self.__class__.buoyancy_force_linearization(service, version, mode, path + ["buoyancy_force_linearization"])
                                super().__init__(service, version, mode, path)
                            class buoyancy_force_linearization(TUIMethod):
                                """
                                .
                                """

                        class pressure_interpolation(TUIMenu):
                            """
                            Set Pressure Interpolation related stability controls.
                            """
                            def __init__(self, service, version, mode, path):
                                self.modified_bfw_scheme = self.__class__.modified_bfw_scheme(service, version, mode, path + ["modified_bfw_scheme"])
                                super().__init__(service, version, mode, path)
                            class modified_bfw_scheme(TUIMethod):
                                """
                                Use modified body force weighted pressure interpolation for better stability.
                                """

                        class rhie_chow_flux(TUIMenu):
                            """
                            Set Rhie-Chow related stability controls.
                            """
                            def __init__(self, service, version, mode, path):
                                self.low_order_rhie_chow = self.__class__.low_order_rhie_chow(service, version, mode, path + ["low_order_rhie_chow"])
                                super().__init__(service, version, mode, path)
                            class low_order_rhie_chow(TUIMethod):
                                """
                                .
                                """

                        class skewness_correction(TUIMenu):
                            """
                            Skewness correction related stabiity controls for multiphase flow.
                            """
                            def __init__(self, service, version, mode, path):
                                self.limit_pressure_correction_gradient = self.__class__.limit_pressure_correction_gradient(service, version, mode, path + ["limit_pressure_correction_gradient"])
                                super().__init__(service, version, mode, path)
                            class limit_pressure_correction_gradient(TUIMethod):
                                """
                                .
                                """

                    class pseudo_time(TUIMenu):
                        """
                        Pseudo-Time stability controls for multiphase flow.
                        """
                        def __init__(self, service, version, mode, path):
                            self.auto_dt_advanced_controls = self.__class__.auto_dt_advanced_controls(service, version, mode, path + ["auto_dt_advanced_controls"])
                            self.false_time_step_linearization = self.__class__.false_time_step_linearization(service, version, mode, path + ["false_time_step_linearization"])
                            self.smoothed_density_stabilization_method = self.__class__.smoothed_density_stabilization_method(service, version, mode, path + ["smoothed_density_stabilization_method"])
                            super().__init__(service, version, mode, path)
                        class false_time_step_linearization(TUIMethod):
                            """
                            .
                            """
                        class smoothed_density_stabilization_method(TUIMethod):
                            """
                            .
                            """

                        class auto_dt_advanced_controls(TUIMenu):
                            """
                            Set automatic time-stepping controls for better solution stability.
                            """
                            def __init__(self, service, version, mode, path):
                                self.dt_factor_max = self.__class__.dt_factor_max(service, version, mode, path + ["dt_factor_max"])
                                self.dt_factor_min = self.__class__.dt_factor_min(service, version, mode, path + ["dt_factor_min"])
                                self.dt_init_limit = self.__class__.dt_init_limit(service, version, mode, path + ["dt_init_limit"])
                                self.dt_max = self.__class__.dt_max(service, version, mode, path + ["dt_max"])
                                self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                                self.max_velocity_ratio = self.__class__.max_velocity_ratio(service, version, mode, path + ["max_velocity_ratio"])
                                super().__init__(service, version, mode, path)
                            class dt_factor_max(TUIMethod):
                                """
                                .
                                """
                            class dt_factor_min(TUIMethod):
                                """
                                .
                                """
                            class dt_init_limit(TUIMethod):
                                """
                                .
                                """
                            class dt_max(TUIMethod):
                                """
                                .
                                """
                            class enable(TUIMethod):
                                """
                                .
                                """
                            class max_velocity_ratio(TUIMethod):
                                """
                                .
                                """

                    class pseudo_transient(TUIMenu):
                        """
                        Pseudo-Time stability controls for multiphase flow.
                        """
                        def __init__(self, service, version, mode, path):
                            self.auto_dt_advanced_controls = self.__class__.auto_dt_advanced_controls(service, version, mode, path + ["auto_dt_advanced_controls"])
                            self.false_time_step_linearization = self.__class__.false_time_step_linearization(service, version, mode, path + ["false_time_step_linearization"])
                            self.smoothed_density_stabilization_method = self.__class__.smoothed_density_stabilization_method(service, version, mode, path + ["smoothed_density_stabilization_method"])
                            super().__init__(service, version, mode, path)
                        class false_time_step_linearization(TUIMethod):
                            """
                            .
                            """
                        class smoothed_density_stabilization_method(TUIMethod):
                            """
                            .
                            """

                        class auto_dt_advanced_controls(TUIMenu):
                            """
                            Set automatic time-stepping controls for better solution stability.
                            """
                            def __init__(self, service, version, mode, path):
                                self.dt_factor_max = self.__class__.dt_factor_max(service, version, mode, path + ["dt_factor_max"])
                                self.dt_factor_min = self.__class__.dt_factor_min(service, version, mode, path + ["dt_factor_min"])
                                self.dt_init_limit = self.__class__.dt_init_limit(service, version, mode, path + ["dt_init_limit"])
                                self.dt_max = self.__class__.dt_max(service, version, mode, path + ["dt_max"])
                                self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                                self.max_velocity_ratio = self.__class__.max_velocity_ratio(service, version, mode, path + ["max_velocity_ratio"])
                                super().__init__(service, version, mode, path)
                            class dt_factor_max(TUIMethod):
                                """
                                .
                                """
                            class dt_factor_min(TUIMethod):
                                """
                                .
                                """
                            class dt_init_limit(TUIMethod):
                                """
                                .
                                """
                            class dt_max(TUIMethod):
                                """
                                .
                                """
                            class enable(TUIMethod):
                                """
                                .
                                """
                            class max_velocity_ratio(TUIMethod):
                                """
                                .
                                """

                    class velocity_limiting(TUIMenu):
                        """
                        Velocity limiting related stabiity controls for multiphase flow.
                        """
                        def __init__(self, service, version, mode, path):
                            self.enable_velocity_limiting = self.__class__.enable_velocity_limiting(service, version, mode, path + ["enable_velocity_limiting"])
                            self.set_damping_strength = self.__class__.set_damping_strength(service, version, mode, path + ["set_damping_strength"])
                            self.set_damping_strengths = self.__class__.set_damping_strengths(service, version, mode, path + ["set_damping_strengths"])
                            self.set_velocity_and_vof_cutoffs = self.__class__.set_velocity_and_vof_cutoffs(service, version, mode, path + ["set_velocity_and_vof_cutoffs"])
                            self.set_velocity_cutoff = self.__class__.set_velocity_cutoff(service, version, mode, path + ["set_velocity_cutoff"])
                            self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                            super().__init__(service, version, mode, path)
                        class enable_velocity_limiting(TUIMethod):
                            """
                            .
                            """
                        class set_damping_strength(TUIMethod):
                            """
                            .
                            """
                        class set_damping_strengths(TUIMethod):
                            """
                            Set phase based damping strength.
                            """
                        class set_velocity_and_vof_cutoffs(TUIMethod):
                            """
                            Set phase based velocity limiting controls.
                            """
                        class set_velocity_cutoff(TUIMethod):
                            """
                            .
                            """
                        class verbosity(TUIMethod):
                            """
                            .
                            """

                class boiling_parameters(TUIMenu):
                    """
                    Multiphase boiling parameters menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.liquid_vof_factor = self.__class__.liquid_vof_factor(service, version, mode, path + ["liquid_vof_factor"])
                        self.thin_film = self.__class__.thin_film(service, version, mode, path + ["thin_film"])
                        super().__init__(service, version, mode, path)
                    class liquid_vof_factor(TUIMethod):
                        """
                        .
                        """
                    class thin_film(TUIMethod):
                        """
                        .
                        """

                class compressible_flow(TUIMenu):
                    """
                    Multiphase compressible numerics options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.alternate_bc_formulation = self.__class__.alternate_bc_formulation(service, version, mode, path + ["alternate_bc_formulation"])
                        self.enhanced_numerics = self.__class__.enhanced_numerics(service, version, mode, path + ["enhanced_numerics"])
                        super().__init__(service, version, mode, path)
                    class alternate_bc_formulation(TUIMethod):
                        """
                        .
                        """
                    class enhanced_numerics(TUIMethod):
                        """
                        .
                        """

                class default_controls(TUIMenu):
                    """
                    Multiphase default controls menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.recommended_defaults_for_existing_cases = self.__class__.recommended_defaults_for_existing_cases(service, version, mode, path + ["recommended_defaults_for_existing_cases"])
                        self.revert_to_pre_r20_point_1_default_settings = self.__class__.revert_to_pre_r20_point_1_default_settings(service, version, mode, path + ["revert_to_pre_r20_point_1_default_settings"])
                        super().__init__(service, version, mode, path)
                    class recommended_defaults_for_existing_cases(TUIMethod):
                        """
                        .
                        """
                    class revert_to_pre_r20_point_1_default_settings(TUIMethod):
                        """
                        .
                        """

                class energy(TUIMenu):
                    """
                    Multiphase energy options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.phasic_wall_heat_flux_form = self.__class__.phasic_wall_heat_flux_form(service, version, mode, path + ["phasic_wall_heat_flux_form"])
                        super().__init__(service, version, mode, path)
                    class phasic_wall_heat_flux_form(TUIMethod):
                        """
                        .
                        """

                class face_pressure_controls(TUIMenu):
                    """
                    Enter the face pressure expert controls menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.face_pressure_options = self.__class__.face_pressure_options(service, version, mode, path + ["face_pressure_options"])
                        super().__init__(service, version, mode, path)
                    class face_pressure_options(TUIMethod):
                        """
                        Set face pressure options.
                        """

                class heat_mass_transfer(TUIMenu):
                    """
                    Multiphase interphase heat and mass transfer numerics options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.area_density = self.__class__.area_density(service, version, mode, path + ["area_density"])
                        self.boiling = self.__class__.boiling(service, version, mode, path + ["boiling"])
                        self.cavitation = self.__class__.cavitation(service, version, mode, path + ["cavitation"])
                        self.evaporation_condensation = self.__class__.evaporation_condensation(service, version, mode, path + ["evaporation_condensation"])
                        self.alternative_energy_treatment = self.__class__.alternative_energy_treatment(service, version, mode, path + ["alternative_energy_treatment"])
                        super().__init__(service, version, mode, path)
                    class alternative_energy_treatment(TUIMethod):
                        """
                        .
                        """

                    class area_density(TUIMenu):
                        """
                        Interfacial area density menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.ia_grad_sym = self.__class__.ia_grad_sym(service, version, mode, path + ["ia_grad_sym"])
                            self.vof_min_seeding = self.__class__.vof_min_seeding(service, version, mode, path + ["vof_min_seeding"])
                            super().__init__(service, version, mode, path)
                        class ia_grad_sym(TUIMethod):
                            """
                            .
                            """
                        class vof_min_seeding(TUIMethod):
                            """
                            .
                            """

                    class boiling(TUIMenu):
                        """
                        Boiling advanced options menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.heat_flux_relaxation_factor = self.__class__.heat_flux_relaxation_factor(service, version, mode, path + ["heat_flux_relaxation_factor"])
                            self.show_expert_options = self.__class__.show_expert_options(service, version, mode, path + ["show_expert_options"])
                            self.two_resistance_boiling_framework = self.__class__.two_resistance_boiling_framework(service, version, mode, path + ["two_resistance_boiling_framework"])
                            super().__init__(service, version, mode, path)
                        class heat_flux_relaxation_factor(TUIMethod):
                            """
                            .
                            """
                        class show_expert_options(TUIMethod):
                            """
                            .
                            """
                        class two_resistance_boiling_framework(TUIMethod):
                            """
                            .
                            """

                    class cavitation(TUIMenu):
                        """
                        Cavitation numerics options menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.display_clipped_pressure = self.__class__.display_clipped_pressure(service, version, mode, path + ["display_clipped_pressure"])
                            self.max_vapor_pressure_ratio = self.__class__.max_vapor_pressure_ratio(service, version, mode, path + ["max_vapor_pressure_ratio"])
                            self.min_vapor_pressure = self.__class__.min_vapor_pressure(service, version, mode, path + ["min_vapor_pressure"])
                            self.p_limit_method = self.__class__.p_limit_method(service, version, mode, path + ["p_limit_method"])
                            self.schnerr_cond_coeff = self.__class__.schnerr_cond_coeff(service, version, mode, path + ["schnerr_cond_coeff"])
                            self.schnerr_evap_coeff = self.__class__.schnerr_evap_coeff(service, version, mode, path + ["schnerr_evap_coeff"])
                            self.turbulent_diffusion = self.__class__.turbulent_diffusion(service, version, mode, path + ["turbulent_diffusion"])
                            super().__init__(service, version, mode, path)
                        class display_clipped_pressure(TUIMethod):
                            """
                            .
                            """
                        class max_vapor_pressure_ratio(TUIMethod):
                            """
                            .
                            """
                        class min_vapor_pressure(TUIMethod):
                            """
                            .
                            """
                        class p_limit_method(TUIMethod):
                            """
                            .
                            """
                        class schnerr_cond_coeff(TUIMethod):
                            """
                            .
                            """
                        class schnerr_evap_coeff(TUIMethod):
                            """
                            .
                            """
                        class turbulent_diffusion(TUIMethod):
                            """
                            .
                            """

                    class evaporation_condensation(TUIMenu):
                        """
                        Evaporation-condensation advanced options menu.
                        """
                        def __init__(self, service, version, mode, path):
                            self.ia_norm_min_limit = self.__class__.ia_norm_min_limit(service, version, mode, path + ["ia_norm_min_limit"])
                            self.max_rel_humiditiy = self.__class__.max_rel_humiditiy(service, version, mode, path + ["max_rel_humiditiy"])
                            self.vof_from_max_limit = self.__class__.vof_from_max_limit(service, version, mode, path + ["vof_from_max_limit"])
                            self.vof_from_min_limit = self.__class__.vof_from_min_limit(service, version, mode, path + ["vof_from_min_limit"])
                            self.vof_to_max_limit = self.__class__.vof_to_max_limit(service, version, mode, path + ["vof_to_max_limit"])
                            self.vof_to_min_limit = self.__class__.vof_to_min_limit(service, version, mode, path + ["vof_to_min_limit"])
                            super().__init__(service, version, mode, path)
                        class ia_norm_min_limit(TUIMethod):
                            """
                            .
                            """
                        class max_rel_humiditiy(TUIMethod):
                            """
                            .
                            """
                        class vof_from_max_limit(TUIMethod):
                            """
                            .
                            """
                        class vof_from_min_limit(TUIMethod):
                            """
                            .
                            """
                        class vof_to_max_limit(TUIMethod):
                            """
                            .
                            """
                        class vof_to_min_limit(TUIMethod):
                            """
                            .
                            """

                class interphase_interactions(TUIMenu):
                    """
                    Interphase interactions for multiphase flow.
                    """
                    def __init__(self, service, version, mode, path):
                        self.turbulence_interaction = self.__class__.turbulence_interaction(service, version, mode, path + ["turbulence_interaction"])
                        self.turbulent_dispersion = self.__class__.turbulent_dispersion(service, version, mode, path + ["turbulent_dispersion"])
                        super().__init__(service, version, mode, path)

                    class turbulence_interaction(TUIMenu):
                        """
                        Enter the menu for the turbulence interaction models.
                        """
                        def __init__(self, service, version, mode, path):
                            self.troshko_hassan = self.__class__.troshko_hassan(service, version, mode, path + ["troshko_hassan"])
                            super().__init__(service, version, mode, path)

                        class troshko_hassan(TUIMenu):
                            """
                            Enter the menu for the Troshko-Hassan turbulence interaction model.
                            """
                            def __init__(self, service, version, mode, path):
                                self.freq_correction = self.__class__.freq_correction(service, version, mode, path + ["freq_correction"])
                                self.legacy = self.__class__.legacy(service, version, mode, path + ["legacy"])
                                self.vof_correction = self.__class__.vof_correction(service, version, mode, path + ["vof_correction"])
                                super().__init__(service, version, mode, path)
                            class freq_correction(TUIMethod):
                                """
                                .
                                """
                            class legacy(TUIMethod):
                                """
                                .
                                """
                            class vof_correction(TUIMethod):
                                """
                                .
                                """

                    class turbulent_dispersion(TUIMenu):
                        """
                        Enter the menu for the turbulent dispersion models.
                        """
                        def __init__(self, service, version, mode, path):
                            self.limiting_function = self.__class__.limiting_function(service, version, mode, path + ["limiting_function"])
                            self.transition_function = self.__class__.transition_function(service, version, mode, path + ["transition_function"])
                            super().__init__(service, version, mode, path)

                        class limiting_function(TUIMenu):
                            """
                            Set the turbulent dispersion limiting function controls.
                            """
                            def __init__(self, service, version, mode, path):
                                self.vof_lower_limit = self.__class__.vof_lower_limit(service, version, mode, path + ["vof_lower_limit"])
                                self.vof_upper_limit = self.__class__.vof_upper_limit(service, version, mode, path + ["vof_upper_limit"])
                                super().__init__(service, version, mode, path)
                            class vof_lower_limit(TUIMethod):
                                """
                                Set the lower volume fraction limit for the limiting function.
                                """
                            class vof_upper_limit(TUIMethod):
                                """
                                Set the upper volume fraction limit for the limiting function.
                                """

                        class transition_function(TUIMenu):
                            """
                            Turbulent dispersion limiting function controls.
                            """
                            def __init__(self, service, version, mode, path):
                                self.vof_lower_limit = self.__class__.vof_lower_limit(service, version, mode, path + ["vof_lower_limit"])
                                self.vof_upper_limit = self.__class__.vof_upper_limit(service, version, mode, path + ["vof_upper_limit"])
                                super().__init__(service, version, mode, path)
                            class vof_lower_limit(TUIMethod):
                                """
                                .
                                """
                            class vof_upper_limit(TUIMethod):
                                """
                                .
                                """

                class porous_media(TUIMenu):
                    """
                    Multiphase miscellaneous porous media numerics menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.capillary_pressure_as_diffusion = self.__class__.capillary_pressure_as_diffusion(service, version, mode, path + ["capillary_pressure_as_diffusion"])
                        self.relative_permeability = self.__class__.relative_permeability(service, version, mode, path + ["relative_permeability"])
                        super().__init__(service, version, mode, path)
                    class capillary_pressure_as_diffusion(TUIMethod):
                        """
                        .
                        """
                    class relative_permeability(TUIMethod):
                        """
                        .
                        """

                class solution_stabilization(TUIMenu):
                    """
                    VOF solution stabilization menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.additional_stabilization_controls = self.__class__.additional_stabilization_controls(service, version, mode, path + ["additional_stabilization_controls"])
                        self.velocity_limiting_treatment = self.__class__.velocity_limiting_treatment(service, version, mode, path + ["velocity_limiting_treatment"])
                        self.execute_additional_stability_controls = self.__class__.execute_additional_stability_controls(service, version, mode, path + ["execute_additional_stability_controls"])
                        self.execute_advanced_stabilization = self.__class__.execute_advanced_stabilization(service, version, mode, path + ["execute_advanced_stabilization"])
                        self.execute_settings_optimization = self.__class__.execute_settings_optimization(service, version, mode, path + ["execute_settings_optimization"])
                        super().__init__(service, version, mode, path)
                    class execute_additional_stability_controls(TUIMethod):
                        """
                        .
                        """
                    class execute_advanced_stabilization(TUIMethod):
                        """
                        .
                        """
                    class execute_settings_optimization(TUIMethod):
                        """
                        .
                        """

                    class additional_stabilization_controls(TUIMenu):
                        """
                        Additional advanced stability controls for VOF.
                        """
                        def __init__(self, service, version, mode, path):
                            self.blended_compressive_scheme = self.__class__.blended_compressive_scheme(service, version, mode, path + ["blended_compressive_scheme"])
                            self.pseudo_time_stabilization = self.__class__.pseudo_time_stabilization(service, version, mode, path + ["pseudo_time_stabilization"])
                            self.pseudo_transient_stabilization = self.__class__.pseudo_transient_stabilization(service, version, mode, path + ["pseudo_transient_stabilization"])
                            super().__init__(service, version, mode, path)
                        class blended_compressive_scheme(TUIMethod):
                            """
                            .
                            """
                        class pseudo_time_stabilization(TUIMethod):
                            """
                            .
                            """
                        class pseudo_transient_stabilization(TUIMethod):
                            """
                            Pseudo-Time Momentum stabilization and False Time Step Linearization methods for VOF.
                            """

                    class velocity_limiting_treatment(TUIMenu):
                        """
                        Velocity limiting related stabibity controls for VOF.
                        """
                        def __init__(self, service, version, mode, path):
                            self.enable_velocity_limiting = self.__class__.enable_velocity_limiting(service, version, mode, path + ["enable_velocity_limiting"])
                            self.set_damping_strength = self.__class__.set_damping_strength(service, version, mode, path + ["set_damping_strength"])
                            self.set_damping_strengths = self.__class__.set_damping_strengths(service, version, mode, path + ["set_damping_strengths"])
                            self.set_velocity_and_vof_cutoffs = self.__class__.set_velocity_and_vof_cutoffs(service, version, mode, path + ["set_velocity_and_vof_cutoffs"])
                            self.set_velocity_cutoff = self.__class__.set_velocity_cutoff(service, version, mode, path + ["set_velocity_cutoff"])
                            self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                            super().__init__(service, version, mode, path)
                        class enable_velocity_limiting(TUIMethod):
                            """
                            .
                            """
                        class set_damping_strength(TUIMethod):
                            """
                            .
                            """
                        class set_damping_strengths(TUIMethod):
                            """
                            Set phase based damping strength.
                            """
                        class set_velocity_and_vof_cutoffs(TUIMethod):
                            """
                            Set phase based velocity limiting controls.
                            """
                        class set_velocity_cutoff(TUIMethod):
                            """
                            .
                            """
                        class verbosity(TUIMethod):
                            """
                            .
                            """

                class viscous_flow(TUIMenu):
                    """
                    Multiphase viscous flow numerics options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.interfacial_artificial_viscosity = self.__class__.interfacial_artificial_viscosity(service, version, mode, path + ["interfacial_artificial_viscosity"])
                        self.turb_visc_based_damping = self.__class__.turb_visc_based_damping(service, version, mode, path + ["turb_visc_based_damping"])
                        self.viscosity_averaging = self.__class__.viscosity_averaging(service, version, mode, path + ["viscosity_averaging"])
                        super().__init__(service, version, mode, path)
                    class interfacial_artificial_viscosity(TUIMethod):
                        """
                        .
                        """
                    class turb_visc_based_damping(TUIMethod):
                        """
                        Turbulence viscosity based damping controls.
                        """
                    class viscosity_averaging(TUIMethod):
                        """
                        .
                        """

            class nita_expert_controls(TUIMenu):
                """
                Enter the nita expert controls menu.
                """
                def __init__(self, service, version, mode, path):
                    self.hybrid_nita_settings = self.__class__.hybrid_nita_settings(service, version, mode, path + ["hybrid_nita_settings"])
                    self.skewness_neighbor_coupling = self.__class__.skewness_neighbor_coupling(service, version, mode, path + ["skewness_neighbor_coupling"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class hybrid_nita_settings(TUIMethod):
                    """
                    Select a hybrid NITA settings option for faster performance and better robustness.
                    """
                class skewness_neighbor_coupling(TUIMethod):
                    """
                    .
                    """
                class verbosity(TUIMethod):
                    """
                    .
                    """

            class open_channel_wave_options(TUIMenu):
                """
                Enter the open-channel-wave-options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.set_buffer_layer_ht = self.__class__.set_buffer_layer_ht(service, version, mode, path + ["set_buffer_layer_ht"])
                    self.set_verbosity = self.__class__.set_verbosity(service, version, mode, path + ["set_verbosity"])
                    self.stokes_wave_variants = self.__class__.stokes_wave_variants(service, version, mode, path + ["stokes_wave_variants"])
                    super().__init__(service, version, mode, path)
                class set_buffer_layer_ht(TUIMethod):
                    """
                    Set bufer layer height between phases for segregated velocity inputs.
                    """
                class set_verbosity(TUIMethod):
                    """
                    Set open channel wave verbosity.
                    """
                class stokes_wave_variants(TUIMethod):
                    """
                    Set stokes wave theory variants.
                    """

            class overset(TUIMenu):
                """
                Enter overset solver options menu.
                """
                def __init__(self, service, version, mode, path):
                    self.expert = self.__class__.expert(service, version, mode, path + ["expert"])
                    self.high_order_pressure = self.__class__.high_order_pressure(service, version, mode, path + ["high_order_pressure"])
                    self.interpolation_method = self.__class__.interpolation_method(service, version, mode, path + ["interpolation_method"])
                    self.orphan_cell_treatment = self.__class__.orphan_cell_treatment(service, version, mode, path + ["orphan_cell_treatment"])
                    super().__init__(service, version, mode, path)
                class high_order_pressure(TUIMethod):
                    """
                    .
                    """
                class interpolation_method(TUIMethod):
                    """
                    Choose the interpolation method for overset interface(s).
                    """
                class orphan_cell_treatment(TUIMethod):
                    """
                    .
                    """

                class expert(TUIMenu):
                    """
                    Enter overset expert solver options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.hybrid_mode_selection = self.__class__.hybrid_mode_selection(service, version, mode, path + ["hybrid_mode_selection"])
                        self.mass_flux_correction_method = self.__class__.mass_flux_correction_method(service, version, mode, path + ["mass_flux_correction_method"])
                        super().__init__(service, version, mode, path)
                    class hybrid_mode_selection(TUIMethod):
                        """
                        Mode for hybrid interpolation.
                        """
                    class mass_flux_correction_method(TUIMethod):
                        """
                        Enter mass flux correction option at overset interfaces.
                        """

            class poor_mesh_numerics(TUIMenu):
                """
                Enter Poor Mesh Numerics Menu.
                """
                def __init__(self, service, version, mode, path):
                    self.register_based = self.__class__.register_based(service, version, mode, path + ["register_based"])
                    self.solution_based_pmn = self.__class__.solution_based_pmn(service, version, mode, path + ["solution_based_pmn"])
                    self.cell_quality_based = self.__class__.cell_quality_based(service, version, mode, path + ["cell_quality_based"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.enhanced_pmn = self.__class__.enhanced_pmn(service, version, mode, path + ["enhanced_pmn"])
                    self.gradient_quality_based = self.__class__.gradient_quality_based(service, version, mode, path + ["gradient_quality_based"])
                    self.improve_tangent_skewness_quality = self.__class__.improve_tangent_skewness_quality(service, version, mode, path + ["improve_tangent_skewness_quality"])
                    self.orthogonality_enhancing_cell_centroids = self.__class__.orthogonality_enhancing_cell_centroids(service, version, mode, path + ["orthogonality_enhancing_cell_centroids"])
                    self.print_poor_elements_count = self.__class__.print_poor_elements_count(service, version, mode, path + ["print_poor_elements_count"])
                    self.reset_poor_elements = self.__class__.reset_poor_elements(service, version, mode, path + ["reset_poor_elements"])
                    self.set_quality_threshold = self.__class__.set_quality_threshold(service, version, mode, path + ["set_quality_threshold"])
                    self.solution_and_quality_based = self.__class__.solution_and_quality_based(service, version, mode, path + ["solution_and_quality_based"])
                    self.tangent_skewness_quality_based = self.__class__.tangent_skewness_quality_based(service, version, mode, path + ["tangent_skewness_quality_based"])
                    self.turbulence_production_term = self.__class__.turbulence_production_term(service, version, mode, path + ["turbulence_production_term"])
                    self.user_defined_on_register = self.__class__.user_defined_on_register(service, version, mode, path + ["user_defined_on_register"])
                    self.user_defined_on_register_auto = self.__class__.user_defined_on_register_auto(service, version, mode, path + ["user_defined_on_register_auto"])
                    super().__init__(service, version, mode, path)
                class cell_quality_based(TUIMethod):
                    """
                    Enable/disable poor mesh numerics on cells with low quality.
                    """
                class enable(TUIMethod):
                    """
                    Solution correction on meshes of poor quality.
                    """
                class enhanced_pmn(TUIMethod):
                    """
                    This option is available with the density-based solver. When enabled, it will apply quality-based poor-mesh-numerics order=1 on any cells with a quality-measure below 0.2. In addition, their CFL number is limited to 1.0.
                    """
                class gradient_quality_based(TUIMethod):
                    """
                    Enable/disable poor mesh numerics based on cell gradient quality.
                    """
                class improve_tangent_skewness_quality(TUIMethod):
                    """
                    Improve tangent skewness metrics for better solver stability.
                    """
                class orthogonality_enhancing_cell_centroids(TUIMethod):
                    """
                    Relocate select cell centroids, to improve orthogonality metrics and solution stability.
                    """
                class print_poor_elements_count(TUIMethod):
                    """
                    .
                    """
                class reset_poor_elements(TUIMethod):
                    """
                    Reset marking of poor cell elements.
                    """
                class set_quality_threshold(TUIMethod):
                    """
                    Set quality threshold.
                    """
                class solution_and_quality_based(TUIMethod):
                    """
                    Enable/disable poor mesh numerics based on solution and cell quality.
                    """
                class tangent_skewness_quality_based(TUIMethod):
                    """
                    Enable/disable poor mesh numerics based on tangent skewness quality.
                    """
                class turbulence_production_term(TUIMethod):
                    """
                    Enable/disable poor mesh numerics for turbulence production term.
                    """
                class user_defined_on_register(TUIMethod):
                    """
                    Include cells in register in poor mesh numerics.
                    """
                class user_defined_on_register_auto(TUIMethod):
                    """
                    Set up the application of poor mesh numerics to cells in registers during the calculation at a specified frequency.
                    """

                class register_based(TUIMenu):
                    """
                    .
                    """
                    def __init__(self, service, version, mode, path):
                        self.create = self.__class__.create(service, version, mode, path + ["create"])
                        self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                        self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                        self.list = self.__class__.list(service, version, mode, path + ["list"])
                        self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                        self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                        self.new = self.__class__.new(service, version, mode, path + ["new"])
                        self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                        self.set = self.__class__.set(service, version, mode, path + ["set"])
                        super().__init__(service, version, mode, path)
                    class create(TUIMethod):
                        """
                        .
                        """
                    class delete(TUIMethod):
                        """
                        .
                        """
                    class edit(TUIMethod):
                        """
                        Edit a definition for poor mesh numerics.
                        """
                    class list(TUIMethod):
                        """
                        .
                        """
                    class list_properties(TUIMethod):
                        """
                        .
                        """
                    class make_a_copy(TUIMethod):
                        """
                        .
                        """
                    class new(TUIMethod):
                        """
                        Add a new definition for poor mesh numerics.
                        """
                    class rename(TUIMethod):
                        """
                        .
                        """
                    class set(TUIMethod):
                        """
                        .
                        """

                class solution_based_pmn(TUIMenu):
                    """
                    Solution based poor-mesh numerics menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                        self.mark_cfl_jump = self.__class__.mark_cfl_jump(service, version, mode, path + ["mark_cfl_jump"])
                        self.mark_cfl_limit = self.__class__.mark_cfl_limit(service, version, mode, path + ["mark_cfl_limit"])
                        self.mark_primary_solution_limits = self.__class__.mark_primary_solution_limits(service, version, mode, path + ["mark_primary_solution_limits"])
                        self.mark_velocity_limit = self.__class__.mark_velocity_limit(service, version, mode, path + ["mark_velocity_limit"])
                        super().__init__(service, version, mode, path)
                    class enable(TUIMethod):
                        """
                        Enable solution based treatment.
                        """
                    class mark_cfl_jump(TUIMethod):
                        """
                        Mark cells exceeding cfl jump in neighborhood.
                        """
                    class mark_cfl_limit(TUIMethod):
                        """
                        Mark cells exceeding cfl limit.
                        """
                    class mark_primary_solution_limits(TUIMethod):
                        """
                        Mark cells violating solution limits.
                        """
                    class mark_velocity_limit(TUIMethod):
                        """
                        Mark cells exceeding velocity limit.
                        """

            class poor_mesh_robustness(TUIMenu):
                """
                Enter Poor Mesh Robustness Menu.
                """
                def __init__(self, service, version, mode, path):
                    self.poor_mesh_numerics = self.__class__.poor_mesh_numerics(service, version, mode, path + ["poor_mesh_numerics"])
                    self.poor_mesh_removal = self.__class__.poor_mesh_removal(service, version, mode, path + ["poor_mesh_removal"])
                    super().__init__(service, version, mode, path)

                class poor_mesh_numerics(TUIMenu):
                    """
                    Enter Poor Mesh Numerics Menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                        self.orthogonal_quality_threshold = self.__class__.orthogonal_quality_threshold(service, version, mode, path + ["orthogonal_quality_threshold"])
                        self.tangent_skewness_threshold = self.__class__.tangent_skewness_threshold(service, version, mode, path + ["tangent_skewness_threshold"])
                        super().__init__(service, version, mode, path)
                    class enable(TUIMethod):
                        """
                        Enable/disable poor mesh numerics.
                        """
                    class orthogonal_quality_threshold(TUIMethod):
                        """
                        Enable/disable poor mesh numerics based on orthogonal quality.
                        """
                    class tangent_skewness_threshold(TUIMethod):
                        """
                        Enable/disable poor mesh numerics based on tangent skewness quality.
                        """

                class poor_mesh_removal(TUIMenu):
                    """
                    Enter Poor Mesh Removal Menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                        self.orthogonal_quality_threshold = self.__class__.orthogonal_quality_threshold(service, version, mode, path + ["orthogonal_quality_threshold"])
                        self.tangent_skewness_threshold = self.__class__.tangent_skewness_threshold(service, version, mode, path + ["tangent_skewness_threshold"])
                        self.warpage_threshold = self.__class__.warpage_threshold(service, version, mode, path + ["warpage_threshold"])
                        super().__init__(service, version, mode, path)
                    class enable(TUIMethod):
                        """
                        Enable/disable poor mesh removal.
                        """
                    class orthogonal_quality_threshold(TUIMethod):
                        """
                        Enable/disable poor mesh removal based on orthogonal quality.
                        """
                    class tangent_skewness_threshold(TUIMethod):
                        """
                        Enable/disable poor mesh removal based on tangent skewness quality.
                        """
                    class warpage_threshold(TUIMethod):
                        """
                        Enable/disable poor mesh removal based on warpage quality.
                        """

            class previous_defaults(TUIMenu):
                """
                Enter previous defaults menu.
                """
                def __init__(self, service, version, mode, path):
                    self.undo_2019r1_default_changes = self.__class__.undo_2019r1_default_changes(service, version, mode, path + ["undo_2019r1_default_changes"])
                    self.undo_2019r3_default_changes = self.__class__.undo_2019r3_default_changes(service, version, mode, path + ["undo_2019r3_default_changes"])
                    self.undo_2021r1_default_changes = self.__class__.undo_2021r1_default_changes(service, version, mode, path + ["undo_2021r1_default_changes"])
                    self.undo_2021r2_default_changes = self.__class__.undo_2021r2_default_changes(service, version, mode, path + ["undo_2021r2_default_changes"])
                    self.undo_2022r1_default_changes = self.__class__.undo_2022r1_default_changes(service, version, mode, path + ["undo_2022r1_default_changes"])
                    self.undo_2023r1_default_changes = self.__class__.undo_2023r1_default_changes(service, version, mode, path + ["undo_2023r1_default_changes"])
                    self.undo_2023r2_default_changes = self.__class__.undo_2023r2_default_changes(service, version, mode, path + ["undo_2023r2_default_changes"])
                    self.undo_2024r1_default_changes = self.__class__.undo_2024r1_default_changes(service, version, mode, path + ["undo_2024r1_default_changes"])
                    self.undo_2024r2_default_changes = self.__class__.undo_2024r2_default_changes(service, version, mode, path + ["undo_2024r2_default_changes"])
                    self.undo_2025r1_default_changes = self.__class__.undo_2025r1_default_changes(service, version, mode, path + ["undo_2025r1_default_changes"])
                    self.undo_2025r2_default_changes = self.__class__.undo_2025r2_default_changes(service, version, mode, path + ["undo_2025r2_default_changes"])
                    self.undo_r19_point_0_default_changes = self.__class__.undo_r19_point_0_default_changes(service, version, mode, path + ["undo_r19_point_0_default_changes"])
                    super().__init__(service, version, mode, path)
                class undo_2019r1_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2019R1.
                    """
                class undo_2019r3_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2019R3.
                    """
                class undo_2021r1_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2021R1.
                    """
                class undo_2021r2_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2021R2.
                    """
                class undo_2022r1_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2022R1.
                    """
                class undo_2023r1_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2023R1.
                    """
                class undo_2023r2_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2023R2.
                    """
                class undo_2024r1_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2024R1.
                    """
                class undo_2024r2_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2024R2.
                    """
                class undo_2025r1_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2025R1.
                    """
                class undo_2025r2_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in 2025R2.
                    """
                class undo_r19_point_0_default_changes(TUIMethod):
                    """
                    Undo default changes introduced in R19.0.
                    """

            class pseudo_time_method(TUIMenu):
                """
                Enter the pseudo time method menu.
                """
                def __init__(self, service, version, mode, path):
                    self.advanced_options = self.__class__.advanced_options(service, version, mode, path + ["advanced_options"])
                    self.convergence_acceleration_for_stretched_meshes = self.__class__.convergence_acceleration_for_stretched_meshes(service, version, mode, path + ["convergence_acceleration_for_stretched_meshes"])
                    self.explicit_relaxation = self.__class__.explicit_relaxation(service, version, mode, path + ["explicit_relaxation"])
                    self.formulation = self.__class__.formulation(service, version, mode, path + ["formulation"])
                    self.global_time_step_settings = self.__class__.global_time_step_settings(service, version, mode, path + ["global_time_step_settings"])
                    self.local_time_step_settings = self.__class__.local_time_step_settings(service, version, mode, path + ["local_time_step_settings"])
                    self.relaxation_bounds = self.__class__.relaxation_bounds(service, version, mode, path + ["relaxation_bounds"])
                    self.relaxation_factors = self.__class__.relaxation_factors(service, version, mode, path + ["relaxation_factors"])
                    self.relaxation_method = self.__class__.relaxation_method(service, version, mode, path + ["relaxation_method"])
                    self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                    super().__init__(service, version, mode, path)
                class advanced_options(TUIMethod):
                    """
                    Enter the advanced options menu to define pseudo time settings for equations.
                    """
                class convergence_acceleration_for_stretched_meshes(TUIMethod):
                    """
                    Enable convergence acceleration for stretched meshes to improve the convergence of the implicit pressure based solver on meshes with high cell stretching.
                    """
                class explicit_relaxation(TUIMethod):
                    """
                    Enable the explicit relaxation option for the pseudo time method.
                    """
                class formulation(TUIMethod):
                    """
                    Select the pseudo time step size formulation for the pseudo time method.
                    """
                class global_time_step_settings(TUIMethod):
                    """
                    Adjust the settings for the global time step formulation.
                    """
                class local_time_step_settings(TUIMethod):
                    """
                    Adjust the settings for the local time step formulation.
                    """
                class relaxation_bounds(TUIMethod):
                    """
                    Select relaxation bounding scheme for pseudo time method.
                    """
                class relaxation_factors(TUIMethod):
                    """
                    Enter the relaxation factors menu to set the pseudo time explicit relaxation factors for equations.
                    """
                class relaxation_method(TUIMethod):
                    """
                    Select relaxation definition for pseudo time method.
                    """
                class verbosity(TUIMethod):
                    """
                    Set the verbosity for the pseudo time method.
                    """

            class slope_limiter_menu(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.direction = self.__class__.direction(service, version, mode, path + ["direction"])
                    self.filter = self.__class__.filter(service, version, mode, path + ["filter"])
                    self.type = self.__class__.type(service, version, mode, path + ["type"])
                    super().__init__(service, version, mode, path)
                class direction(TUIMethod):
                    """
                    .
                    """
                class filter(TUIMethod):
                    """
                    .
                    """
                class type(TUIMethod):
                    """
                    .
                    """

            class stabilization_tools(TUIMenu):
                """
                Enter stabilization tools menu.
                """
                def __init__(self, service, version, mode, path):
                    self.contingency_tools = self.__class__.contingency_tools(service, version, mode, path + ["contingency_tools"])
                    self.diagnostics_tools = self.__class__.diagnostics_tools(service, version, mode, path + ["diagnostics_tools"])
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.stabilization_mode = self.__class__.stabilization_mode(service, version, mode, path + ["stabilization_mode"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    Enable/disable stabilization tools.
                    """
                class stabilization_mode(TUIMethod):
                    """
                    Select solver stabilization mode.
                    """

                class contingency_tools(TUIMenu):
                    """
                    Show contingency tools.
                    """
                    def __init__(self, service, version, mode, path):
                        self.delete_invalid_cells = self.__class__.delete_invalid_cells(service, version, mode, path + ["delete_invalid_cells"])
                        self.divergence_prevention = self.__class__.divergence_prevention(service, version, mode, path + ["divergence_prevention"])
                        self.linear_solver_adjustment = self.__class__.linear_solver_adjustment(service, version, mode, path + ["linear_solver_adjustment"])
                        super().__init__(service, version, mode, path)
                    class delete_invalid_cells(TUIMethod):
                        """
                        Delete invalid cells from domain.
                        """
                    class divergence_prevention(TUIMethod):
                        """
                        Adjust numerical settings when divergence patter identified.
                        """
                    class linear_solver_adjustment(TUIMethod):
                        """
                        Adjust linear solver settings for better robustness.
                        """

                class diagnostics_tools(TUIMenu):
                    """
                    Show diagnostics tools.
                    """
                    def __init__(self, service, version, mode, path):
                        self.clear_divergence_tracker_files = self.__class__.clear_divergence_tracker_files(service, version, mode, path + ["clear_divergence_tracker_files"])
                        self.diagnostics_visualization = self.__class__.diagnostics_visualization(service, version, mode, path + ["diagnostics_visualization"])
                        self.global_exterma_tracker = self.__class__.global_exterma_tracker(service, version, mode, path + ["global_exterma_tracker"])
                        self.inspector = self.__class__.inspector(service, version, mode, path + ["inspector"])
                        self.local_divergence_tracker = self.__class__.local_divergence_tracker(service, version, mode, path + ["local_divergence_tracker"])
                        super().__init__(service, version, mode, path)
                    class clear_divergence_tracker_files(TUIMethod):
                        """
                        Clear divergence tracker history files.
                        """
                    class diagnostics_visualization(TUIMethod):
                        """
                        Display diagnostics fields.
                        """
                    class global_exterma_tracker(TUIMethod):
                        """
                        Effortlessly monitor global maximum and minimum exterma values during simulation.
                        """
                    class inspector(TUIMethod):
                        """
                        Inspect mesh and case data.
                        """
                    class local_divergence_tracker(TUIMethod):
                        """
                        Stop simulation after divergence incident detected.
                        """

            class transient_controls(TUIMenu):
                """
                Enter into the transient controls menu.
                """
                def __init__(self, service, version, mode, path):
                    self.multiphase_specific_time_constraints = self.__class__.multiphase_specific_time_constraints(service, version, mode, path + ["multiphase_specific_time_constraints"])
                    self.cfl_based_time_stepping = self.__class__.cfl_based_time_stepping(service, version, mode, path + ["cfl_based_time_stepping"])
                    self.cfl_based_time_stepping_advanced_options = self.__class__.cfl_based_time_stepping_advanced_options(service, version, mode, path + ["cfl_based_time_stepping_advanced_options"])
                    self.duration_specification_method = self.__class__.duration_specification_method(service, version, mode, path + ["duration_specification_method"])
                    self.error_based_time_stepping = self.__class__.error_based_time_stepping(service, version, mode, path + ["error_based_time_stepping"])
                    self.extrapolate_eqn_vars = self.__class__.extrapolate_eqn_vars(service, version, mode, path + ["extrapolate_eqn_vars"])
                    self.extrapolate_vars = self.__class__.extrapolate_vars(service, version, mode, path + ["extrapolate_vars"])
                    self.fixed_periodic = self.__class__.fixed_periodic(service, version, mode, path + ["fixed_periodic"])
                    self.fixed_user_specified = self.__class__.fixed_user_specified(service, version, mode, path + ["fixed_user_specified"])
                    self.incremental_time = self.__class__.incremental_time(service, version, mode, path + ["incremental_time"])
                    self.max_flow_time = self.__class__.max_flow_time(service, version, mode, path + ["max_flow_time"])
                    self.max_iterations_per_time_step = self.__class__.max_iterations_per_time_step(service, version, mode, path + ["max_iterations_per_time_step"])
                    self.multiphase_specific_time_stepping = self.__class__.multiphase_specific_time_stepping(service, version, mode, path + ["multiphase_specific_time_stepping"])
                    self.number_of_time_steps = self.__class__.number_of_time_steps(service, version, mode, path + ["number_of_time_steps"])
                    self.predict_next_time = self.__class__.predict_next_time(service, version, mode, path + ["predict_next_time"])
                    self.rotating_mesh_flow_predictor = self.__class__.rotating_mesh_flow_predictor(service, version, mode, path + ["rotating_mesh_flow_predictor"])
                    self.solid_time_step_size = self.__class__.solid_time_step_size(service, version, mode, path + ["solid_time_step_size"])
                    self.solution_status = self.__class__.solution_status(service, version, mode, path + ["solution_status"])
                    self.specified_time_step = self.__class__.specified_time_step(service, version, mode, path + ["specified_time_step"])
                    self.time_step_size = self.__class__.time_step_size(service, version, mode, path + ["time_step_size"])
                    self.time_step_size_for_acoustic_export = self.__class__.time_step_size_for_acoustic_export(service, version, mode, path + ["time_step_size_for_acoustic_export"])
                    self.total_number_of_time_steps = self.__class__.total_number_of_time_steps(service, version, mode, path + ["total_number_of_time_steps"])
                    self.total_time = self.__class__.total_time(service, version, mode, path + ["total_time"])
                    self.udf_based_time_stepping = self.__class__.udf_based_time_stepping(service, version, mode, path + ["udf_based_time_stepping"])
                    self.undo_timestep = self.__class__.undo_timestep(service, version, mode, path + ["undo_timestep"])
                    super().__init__(service, version, mode, path)
                class cfl_based_time_stepping(TUIMethod):
                    """
                    Set CFL-based adaptive time-stepping parameters.
                    """
                class cfl_based_time_stepping_advanced_options(TUIMethod):
                    """
                    .
                    """
                class duration_specification_method(TUIMethod):
                    """
                    Set Duration Specification Method: [0] Incremental Time Steps, [1] Total Time Steps, [2] Total Time, [3] Incremental Time.
                    """
                class error_based_time_stepping(TUIMethod):
                    """
                    Set Error-based adaptive time-stepping parameters.
                    """
                class extrapolate_eqn_vars(TUIMethod):
                    """
                    Enter the extrapolation menu.
                    """
                class extrapolate_vars(TUIMethod):
                    """
                    .
                    """
                class fixed_periodic(TUIMethod):
                    """
                    Set period- or frequency-based fixed time-stepping parameters.
                    """
                class fixed_user_specified(TUIMethod):
                    """
                    Enable user-specified fixed time stepping method.
                    """
                class incremental_time(TUIMethod):
                    """
                    .
                    """
                class max_flow_time(TUIMethod):
                    """
                    .
                    """
                class max_iterations_per_time_step(TUIMethod):
                    """
                    .
                    """
                class multiphase_specific_time_stepping(TUIMethod):
                    """
                    .
                    """
                class number_of_time_steps(TUIMethod):
                    """
                    .
                    """
                class predict_next_time(TUIMethod):
                    """
                    .
                    """
                class rotating_mesh_flow_predictor(TUIMethod):
                    """
                    Improve prediction of flow field at time step n+1 for rotating mesh.
                    """
                class solid_time_step_size(TUIMethod):
                    """
                    Specify a different time step size for solid zones.
                    """
                class solution_status(TUIMethod):
                    """
                    .
                    """
                class specified_time_step(TUIMethod):
                    """
                    .
                    """
                class time_step_size(TUIMethod):
                    """
                    .
                    """
                class time_step_size_for_acoustic_export(TUIMethod):
                    """
                    .
                    """
                class total_number_of_time_steps(TUIMethod):
                    """
                    .
                    """
                class total_time(TUIMethod):
                    """
                    .
                    """
                class udf_based_time_stepping(TUIMethod):
                    """
                    Set the time-stepping parameters for user-defined time stepping method.
                    """
                class undo_timestep(TUIMethod):
                    """
                    Undo the previous time step.
                    """

                class multiphase_specific_time_constraints(TUIMenu):
                    """
                    Set Multiphase-specific time constraints.
                    """
                    def __init__(self, service, version, mode, path):
                        self.time_scale_options = self.__class__.time_scale_options(service, version, mode, path + ["time_scale_options"])
                        self.moving_mesh_cfl_constraint = self.__class__.moving_mesh_cfl_constraint(service, version, mode, path + ["moving_mesh_cfl_constraint"])
                        self.physics_based_constraint = self.__class__.physics_based_constraint(service, version, mode, path + ["physics_based_constraint"])
                        self.verbosity = self.__class__.verbosity(service, version, mode, path + ["verbosity"])
                        super().__init__(service, version, mode, path)
                    class moving_mesh_cfl_constraint(TUIMethod):
                        """
                        .
                        """
                    class physics_based_constraint(TUIMethod):
                        """
                        .
                        """
                    class verbosity(TUIMethod):
                        """
                        .
                        """

                    class time_scale_options(TUIMenu):
                        """
                        .
                        """
                        def __init__(self, service, version, mode, path):
                            self.acoustic_scale = self.__class__.acoustic_scale(service, version, mode, path + ["acoustic_scale"])
                            self.gravity_scale = self.__class__.gravity_scale(service, version, mode, path + ["gravity_scale"])
                            self.surface_tension_scale = self.__class__.surface_tension_scale(service, version, mode, path + ["surface_tension_scale"])
                            self.viscous_scale = self.__class__.viscous_scale(service, version, mode, path + ["viscous_scale"])
                            super().__init__(service, version, mode, path)
                        class acoustic_scale(TUIMethod):
                            """
                            .
                            """
                        class gravity_scale(TUIMethod):
                            """
                            .
                            """
                        class surface_tension_scale(TUIMethod):
                            """
                            .
                            """
                        class viscous_scale(TUIMethod):
                            """
                            .
                            """

            class warped_face_gradient_correction(TUIMenu):
                """
                Enter warped-face-gradient-correction menu.
                """
                def __init__(self, service, version, mode, path):
                    self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                    self.turbulence_options = self.__class__.turbulence_options(service, version, mode, path + ["turbulence_options"])
                    super().__init__(service, version, mode, path)
                class enable(TUIMethod):
                    """
                    Enable Warped-Face Gradient Correction.
                    """
                class turbulence_options(TUIMethod):
                    """
                    Set turbulence Warped Face Gradient Correction.
                    """

            class zonal_pbns_solution_controls(TUIMenu):
                """
                Set under-relaxation facotrs for zonal pbns.
                """
                def __init__(self, service, version, mode, path):
                    self.amg_options = self.__class__.amg_options(service, version, mode, path + ["amg_options"])
                    self.pseudo_time_method = self.__class__.pseudo_time_method(service, version, mode, path + ["pseudo_time_method"])
                    self.coupled_flow_controls = self.__class__.coupled_flow_controls(service, version, mode, path + ["coupled_flow_controls"])
                    self.multi_grid_amg = self.__class__.multi_grid_amg(service, version, mode, path + ["multi_grid_amg"])
                    self.multi_grid_controls = self.__class__.multi_grid_controls(service, version, mode, path + ["multi_grid_controls"])
                    self.segregated_flow_controls = self.__class__.segregated_flow_controls(service, version, mode, path + ["segregated_flow_controls"])
                    self.under_relaxations = self.__class__.under_relaxations(service, version, mode, path + ["under_relaxations"])
                    super().__init__(service, version, mode, path)
                class coupled_flow_controls(TUIMethod):
                    """
                    Set coupled solver under-relaxation and flow courant number.
                    """
                class multi_grid_amg(TUIMethod):
                    """
                    Set the parameters that govern the algebraic multigrid procedure.
                    """
                class multi_grid_controls(TUIMethod):
                    """
                    Enter the multi-grid-controls menu.
                    """
                class segregated_flow_controls(TUIMethod):
                    """
                    Set segregated solver correction.
                    """
                class under_relaxations(TUIMethod):
                    """
                    Set under-relaxation facotrs for zonal pbns with pseudo local time stepping.
                    """

                class amg_options(TUIMenu):
                    """
                    Enter AMG options menu.
                    """
                    def __init__(self, service, version, mode, path):
                        self.aggressive_amg_coarsening = self.__class__.aggressive_amg_coarsening(service, version, mode, path + ["aggressive_amg_coarsening"])
                        self.amg_gpgpu_options = self.__class__.amg_gpgpu_options(service, version, mode, path + ["amg_gpgpu_options"])
                        self.conservative_amg_coarsening = self.__class__.conservative_amg_coarsening(service, version, mode, path + ["conservative_amg_coarsening"])
                        self.laplace_coarsening = self.__class__.laplace_coarsening(service, version, mode, path + ["laplace_coarsening"])
                        super().__init__(service, version, mode, path)
                    class aggressive_amg_coarsening(TUIMethod):
                        """
                        Use aggressive AMG coarsening.
                        """
                    class amg_gpgpu_options(TUIMethod):
                        """
                        Set GPGPU AMG solver options.
                        """
                    class conservative_amg_coarsening(TUIMethod):
                        """
                        Use conservative AMG coarsening?.
                        """
                    class laplace_coarsening(TUIMethod):
                        """
                        Set AMG laplace coarsening options.
                        """

                class pseudo_time_method(TUIMenu):
                    """
                    Set pseudo time method for zonal pbns.
                    """
                    def __init__(self, service, version, mode, path):
                        self.global_time_step_advanced_options = self.__class__.global_time_step_advanced_options(service, version, mode, path + ["global_time_step_advanced_options"])
                        self.global_time_step_settings = self.__class__.global_time_step_settings(service, version, mode, path + ["global_time_step_settings"])
                        self.global_time_step_verbosity = self.__class__.global_time_step_verbosity(service, version, mode, path + ["global_time_step_verbosity"])
                        self.local_time_step_advanced_options = self.__class__.local_time_step_advanced_options(service, version, mode, path + ["local_time_step_advanced_options"])
                        self.local_time_step_settings = self.__class__.local_time_step_settings(service, version, mode, path + ["local_time_step_settings"])
                        self.local_time_step_verbosity = self.__class__.local_time_step_verbosity(service, version, mode, path + ["local_time_step_verbosity"])
                        self.pseudo_global_relaxation = self.__class__.pseudo_global_relaxation(service, version, mode, path + ["pseudo_global_relaxation"])
                        self.pseudo_local_relaxation = self.__class__.pseudo_local_relaxation(service, version, mode, path + ["pseudo_local_relaxation"])
                        super().__init__(service, version, mode, path)
                    class global_time_step_advanced_options(TUIMethod):
                        """
                        Enter the advanced options menu to define pseudo time global time step settings for equations.
                        """
                    class global_time_step_settings(TUIMethod):
                        """
                        Adjust the settings for the global time step formulation.
                        """
                    class global_time_step_verbosity(TUIMethod):
                        """
                        .
                        """
                    class local_time_step_advanced_options(TUIMethod):
                        """
                        Enter the advanced options menu to define pseudo time global time step settings for equations.
                        """
                    class local_time_step_settings(TUIMethod):
                        """
                        .
                        """
                    class local_time_step_verbosity(TUIMethod):
                        """
                        .
                        """
                    class pseudo_global_relaxation(TUIMethod):
                        """
                        Set under-relaxation facotrs for zonal pbns with pseudo global time stepping.
                        """
                    class pseudo_local_relaxation(TUIMethod):
                        """
                        Set under-relaxation facotrs for zonal pbns with pseudo local time stepping.
                        """

    class surface(TUIMenu):
        """
        Enter the data surface manipulation menu.
        """
        def __init__(self, service, version, mode, path):
            self.post_processing_volume = self.__class__.post_processing_volume(service, version, mode, path + ["post_processing_volume"])
            self.query = self.__class__.query(service, version, mode, path + ["query"])
            self.circle_slice = self.__class__.circle_slice(service, version, mode, path + ["circle_slice"])
            self.closest_point_search = self.__class__.closest_point_search(service, version, mode, path + ["closest_point_search"])
            self.cone_slice = self.__class__.cone_slice(service, version, mode, path + ["cone_slice"])
            self.create_imprint_surface = self.__class__.create_imprint_surface(service, version, mode, path + ["create_imprint_surface"])
            self.delete_surface = self.__class__.delete_surface(service, version, mode, path + ["delete_surface"])
            self.edit_surface = self.__class__.edit_surface(service, version, mode, path + ["edit_surface"])
            self.ellipsoid_slice = self.__class__.ellipsoid_slice(service, version, mode, path + ["ellipsoid_slice"])
            self.expression_volume = self.__class__.expression_volume(service, version, mode, path + ["expression_volume"])
            self.group_surfaces = self.__class__.group_surfaces(service, version, mode, path + ["group_surfaces"])
            self.import_surface = self.__class__.import_surface(service, version, mode, path + ["import_surface"])
            self.imprint_surface = self.__class__.imprint_surface(service, version, mode, path + ["imprint_surface"])
            self.iso_clip = self.__class__.iso_clip(service, version, mode, path + ["iso_clip"])
            self.iso_clip_multiple = self.__class__.iso_clip_multiple(service, version, mode, path + ["iso_clip_multiple"])
            self.iso_surface = self.__class__.iso_surface(service, version, mode, path + ["iso_surface"])
            self.line_slice = self.__class__.line_slice(service, version, mode, path + ["line_slice"])
            self.line_surface = self.__class__.line_surface(service, version, mode, path + ["line_surface"])
            self.list_surfaces = self.__class__.list_surfaces(service, version, mode, path + ["list_surfaces"])
            self.mouse_line = self.__class__.mouse_line(service, version, mode, path + ["mouse_line"])
            self.mouse_plane = self.__class__.mouse_plane(service, version, mode, path + ["mouse_plane"])
            self.mouse_rake = self.__class__.mouse_rake(service, version, mode, path + ["mouse_rake"])
            self.multiple_iso_surfaces = self.__class__.multiple_iso_surfaces(service, version, mode, path + ["multiple_iso_surfaces"])
            self.multiple_plane_surfaces = self.__class__.multiple_plane_surfaces(service, version, mode, path + ["multiple_plane_surfaces"])
            self.multiple_zone_surfaces = self.__class__.multiple_zone_surfaces(service, version, mode, path + ["multiple_zone_surfaces"])
            self.partition_surface = self.__class__.partition_surface(service, version, mode, path + ["partition_surface"])
            self.plane = self.__class__.plane(service, version, mode, path + ["plane"])
            self.plane_bounded = self.__class__.plane_bounded(service, version, mode, path + ["plane_bounded"])
            self.plane_point_n_normal = self.__class__.plane_point_n_normal(service, version, mode, path + ["plane_point_n_normal"])
            self.plane_slice = self.__class__.plane_slice(service, version, mode, path + ["plane_slice"])
            self.plane_surf_aligned = self.__class__.plane_surf_aligned(service, version, mode, path + ["plane_surf_aligned"])
            self.plane_surface = self.__class__.plane_surface(service, version, mode, path + ["plane_surface"])
            self.plane_view_plane_align = self.__class__.plane_view_plane_align(service, version, mode, path + ["plane_view_plane_align"])
            self.point_array = self.__class__.point_array(service, version, mode, path + ["point_array"])
            self.point_surface = self.__class__.point_surface(service, version, mode, path + ["point_surface"])
            self.quadric_slice = self.__class__.quadric_slice(service, version, mode, path + ["quadric_slice"])
            self.rake_surface = self.__class__.rake_surface(service, version, mode, path + ["rake_surface"])
            self.rename_surface = self.__class__.rename_surface(service, version, mode, path + ["rename_surface"])
            self.rendering_priority = self.__class__.rendering_priority(service, version, mode, path + ["rendering_priority"])
            self.reset_zone_surfaces = self.__class__.reset_zone_surfaces(service, version, mode, path + ["reset_zone_surfaces"])
            self.sphere_slice = self.__class__.sphere_slice(service, version, mode, path + ["sphere_slice"])
            self.split_surface = self.__class__.split_surface(service, version, mode, path + ["split_surface"])
            self.structural_point_surface = self.__class__.structural_point_surface(service, version, mode, path + ["structural_point_surface"])
            self.surface_cells = self.__class__.surface_cells(service, version, mode, path + ["surface_cells"])
            self.transform_surface = self.__class__.transform_surface(service, version, mode, path + ["transform_surface"])
            self.ungroup_surface = self.__class__.ungroup_surface(service, version, mode, path + ["ungroup_surface"])
            self.zone_surface = self.__class__.zone_surface(service, version, mode, path + ["zone_surface"])
            super().__init__(service, version, mode, path)
        class circle_slice(TUIMethod):
            """
            Extract a circular slice.
            """
        class closest_point_search(TUIMethod):
            """
            Enable the point surface algorithm to look for the nearest point instead of reporting a creation failure.
            """
        class cone_slice(TUIMethod):
            """
            Extract a cone slice.
            """
        class create_imprint_surface(TUIMethod):
            """
            Imprint surface.
            """
        class delete_surface(TUIMethod):
            """
            Remove a defined data surface.
            """
        class edit_surface(TUIMethod):
            """
            Edit a defined data surface.
            """
        class ellipsoid_slice(TUIMethod):
            """
            Extract a ellipsoid slice.
            """
        class expression_volume(TUIMethod):
            """
            Create volume with boolean expression.
            """
        class group_surfaces(TUIMethod):
            """
            Group a set of surfaces.
            """
        class import_surface(TUIMethod):
            """
            Import surface.
            """
        class imprint_surface(TUIMethod):
            """
            Imprint surface.
            """
        class iso_clip(TUIMethod):
            """
            Clip a data surface (surface, curve, or point) between two iso-values.
            """
        class iso_clip_multiple(TUIMethod):
            """
            Clip a data surface (surface, curve, or point) between two iso-values.
            """
        class iso_surface(TUIMethod):
            """
            Extract an iso-surface (surface, curve, or point) from the curent data field.
            """
        class line_slice(TUIMethod):
            """
            Extract a linear slice.
            """
        class line_surface(TUIMethod):
            """
            Define a "line" surface by specifying the two endpoint coordinates.
            """
        class list_surfaces(TUIMethod):
            """
            List the number of facets in the defined surfaces.
            """
        class mouse_line(TUIMethod):
            """
            Define a line surface using the mouse to select two points.
            """
        class mouse_plane(TUIMethod):
            """
            Define a plane surface using the mouse to select three points.
            """
        class mouse_rake(TUIMethod):
            """
            Define a "rake" surface using the mouse to select the end points.
            """
        class multiple_iso_surfaces(TUIMethod):
            """
            .
            """
        class multiple_plane_surfaces(TUIMethod):
            """
            .
            """
        class multiple_zone_surfaces(TUIMethod):
            """
            Create multiple data surfaces at a time.
            """
        class partition_surface(TUIMethod):
            """
            Define a data surface on mesh faces on the partition boundary.
            """
        class plane(TUIMethod):
            """
            Create a plane given 3 points bounded by the domain.
            """
        class plane_bounded(TUIMethod):
            """
            Create a bounded surface.
            """
        class plane_point_n_normal(TUIMethod):
            """
            Create a plane from a point and normal.
            """
        class plane_slice(TUIMethod):
            """
            Extract a planar slice.
            """
        class plane_surf_aligned(TUIMethod):
            """
            Create a plane aligned to a surface.
            """
        class plane_surface(TUIMethod):
            """
            Create a plane from a coordinate plane, point and normal, or three points.
            """
        class plane_view_plane_align(TUIMethod):
            """
            Create a plane aligned to a view-plane.
            """
        class point_array(TUIMethod):
            """
            Extract a rectangular array of data points.
            """
        class point_surface(TUIMethod):
            """
            Define a "point" surface by specifying the coordinates.
            """
        class quadric_slice(TUIMethod):
            """
            Extract a quadric slice.
            """
        class rake_surface(TUIMethod):
            """
            Define a "rake" surface by specifying the end points.
            """
        class rename_surface(TUIMethod):
            """
            Rename a defined data surface.
            """
        class rendering_priority(TUIMethod):
            """
            Define Priority for given surface id.
            """
        class reset_zone_surfaces(TUIMethod):
            """
            .
            """
        class sphere_slice(TUIMethod):
            """
            Extract a spherical slice.
            """
        class split_surface(TUIMethod):
            """
            Split Surface.
            """
        class structural_point_surface(TUIMethod):
            """
            Define a "structural point" surface by specifying the coordinates.
            """
        class surface_cells(TUIMethod):
            """
            Extract all cells intersected by a data surface.
            """
        class transform_surface(TUIMethod):
            """
            Transform surface.
            """
        class ungroup_surface(TUIMethod):
            """
            Ungroup the surface(if grouped).
            """
        class zone_surface(TUIMethod):
            """
            Define a data surface on a mesh zone.
            """

        class post_processing_volume(TUIMenu):
            """
            Enter post-processing volume menu.
            """
            def __init__(self, service, version, mode, path):
                self.create_from_file = self.__class__.create_from_file(service, version, mode, path + ["create_from_file"])
                self.create_octree = self.__class__.create_octree(service, version, mode, path + ["create_octree"])
                super().__init__(service, version, mode, path)
            class create_from_file(TUIMethod):
                """
                Read post-processing mesh from file.
                """
            class create_octree(TUIMethod):
                """
                Create post-processing octree mesh based on current case.
                """

        class query(TUIMenu):
            """
            Enter surface query menu.
            """
            def __init__(self, service, version, mode, path):
                self.delete_query = self.__class__.delete_query(service, version, mode, path + ["delete_query"])
                self.list_named_selection = self.__class__.list_named_selection(service, version, mode, path + ["list_named_selection"])
                self.list_queries = self.__class__.list_queries(service, version, mode, path + ["list_queries"])
                self.list_surfaces = self.__class__.list_surfaces(service, version, mode, path + ["list_surfaces"])
                self.named_surface_list = self.__class__.named_surface_list(service, version, mode, path + ["named_surface_list"])
                super().__init__(service, version, mode, path)
            class delete_query(TUIMethod):
                """
                Delete saved query.
                """
            class list_named_selection(TUIMethod):
                """
                List named selection of surface type.
                """
            class list_queries(TUIMethod):
                """
                List all saved queries.
                """
            class list_surfaces(TUIMethod):
                """
                List surfaces.
                """
            class named_surface_list(TUIMethod):
                """
                Create named list of surfaces.
                """

    class transient_post_processing(TUIMenu):
        """
        Enter transient postprocessing menu.
        """
        def __init__(self, service, version, mode, path):
            self.timestep_selector = self.__class__.timestep_selector(service, version, mode, path + ["timestep_selector"])
            self.animation = self.__class__.animation(service, version, mode, path + ["animation"])
            self.compare_results = self.__class__.compare_results(service, version, mode, path + ["compare_results"])
            self.compute_and_clip_range = self.__class__.compute_and_clip_range(service, version, mode, path + ["compute_and_clip_range"])
            self.display = self.__class__.display(service, version, mode, path + ["display"])
            self.enable_transient_postprocessing = self.__class__.enable_transient_postprocessing(service, version, mode, path + ["enable_transient_postprocessing"])
            self.monitor = self.__class__.monitor(service, version, mode, path + ["monitor"])
            self.select_active_data_source = self.__class__.select_active_data_source(service, version, mode, path + ["select_active_data_source"])
            self.update_active_results = self.__class__.update_active_results(service, version, mode, path + ["update_active_results"])
            super().__init__(service, version, mode, path)
        class animation(TUIMethod):
            """
            .
            """
        class compare_results(TUIMethod):
            """
            .
            """
        class compute_and_clip_range(TUIMethod):
            """
            .
            """
        class display(TUIMethod):
            """
            .
            """
        class enable_transient_postprocessing(TUIMethod):
            """
            .
            """
        class monitor(TUIMethod):
            """
            .
            """
        class select_active_data_source(TUIMethod):
            """
            Select active data source.
            """
        class update_active_results(TUIMethod):
            """
            Update active results.
            """

        class timestep_selector(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.custom = self.__class__.custom(service, version, mode, path + ["custom"])
                self.all = self.__class__.all(service, version, mode, path + ["all"])
                self.first = self.__class__.first(service, version, mode, path + ["first"])
                self.last = self.__class__.last(service, version, mode, path + ["last"])
                super().__init__(service, version, mode, path)
            class all(TUIMethod):
                """
                .
                """
            class first(TUIMethod):
                """
                .
                """
            class last(TUIMethod):
                """
                .
                """

            class custom(TUIMenu):
                """
                .
                """
                def __init__(self, service, version, mode, path):
                    self.timestep_list = self.__class__.timestep_list(service, version, mode, path + ["timestep_list"])
                    self.uniform = self.__class__.uniform(service, version, mode, path + ["uniform"])
                    super().__init__(service, version, mode, path)
                class timestep_list(TUIMethod):
                    """
                    .
                    """
                class uniform(TUIMethod):
                    """
                    .
                    """

    class turbo_post(TUIMenu):
        """
        Enter the turbo menu.
        """
        def __init__(self, service, version, mode, path):
            self.avg_contours = self.__class__.avg_contours(service, version, mode, path + ["avg_contours"])
            self.compute_report = self.__class__.compute_report(service, version, mode, path + ["compute_report"])
            self.current_topology = self.__class__.current_topology(service, version, mode, path + ["current_topology"])
            self.two_d_contours = self.__class__.two_d_contours(service, version, mode, path + ["two_d_contours"])
            self.write_report = self.__class__.write_report(service, version, mode, path + ["write_report"])
            self.xy_plot_avg = self.__class__.xy_plot_avg(service, version, mode, path + ["xy_plot_avg"])
            super().__init__(service, version, mode, path)
        class avg_contours(TUIMethod):
            """
            Display average contours.
            """
        class compute_report(TUIMethod):
            """
            Compute the turbo report.
            """
        class current_topology(TUIMethod):
            """
            Set the current turbo topology for global use.
            """
        class two_d_contours(TUIMethod):
            """
            Display 2d contours.
            """
        class write_report(TUIMethod):
            """
            Write the turbo report to file.
            """
        class xy_plot_avg(TUIMethod):
            """
            Display average xy plot.
            """

    class turbo_workflow(TUIMenu):
        """
        Enter the turbo workflow menu.
        """
        def __init__(self, service, version, mode, path):
            self.workflow = self.__class__.workflow(service, version, mode, path + ["workflow"])
            super().__init__(service, version, mode, path)

        class workflow(TUIMenu):
            """
            Enter the workflow menu.
            """
            def __init__(self, service, version, mode, path):
                self.disable = self.__class__.disable(service, version, mode, path + ["disable"])
                self.enable = self.__class__.enable(service, version, mode, path + ["enable"])
                self.reset = self.__class__.reset(service, version, mode, path + ["reset"])
                super().__init__(service, version, mode, path)
            class disable(TUIMethod):
                """
                Disable the workflow.
                """
            class enable(TUIMethod):
                """
                Enable the workflow.
                """
            class reset(TUIMethod):
                """
                Reset the workflow.
                """

    class views(TUIMenu):
        """
        .
        """
        def __init__(self, service, version, mode, path):
            self.camera = self.__class__.camera(service, version, mode, path + ["camera"])
            self.display_states = self.__class__.display_states(service, version, mode, path + ["display_states"])
            self.mirror_planes = self.__class__.mirror_planes(service, version, mode, path + ["mirror_planes"])
            self.rendering_options = self.__class__.rendering_options(service, version, mode, path + ["rendering_options"])
            self.apply_mirror_planes = self.__class__.apply_mirror_planes(service, version, mode, path + ["apply_mirror_planes"])
            self.auto_scale = self.__class__.auto_scale(service, version, mode, path + ["auto_scale"])
            self.default_view = self.__class__.default_view(service, version, mode, path + ["default_view"])
            self.delete_view = self.__class__.delete_view(service, version, mode, path + ["delete_view"])
            self.last_view = self.__class__.last_view(service, version, mode, path + ["last_view"])
            self.list_views = self.__class__.list_views(service, version, mode, path + ["list_views"])
            self.mirror_zones = self.__class__.mirror_zones(service, version, mode, path + ["mirror_zones"])
            self.next_view = self.__class__.next_view(service, version, mode, path + ["next_view"])
            self.read_views = self.__class__.read_views(service, version, mode, path + ["read_views"])
            self.restore_view = self.__class__.restore_view(service, version, mode, path + ["restore_view"])
            self.save_view = self.__class__.save_view(service, version, mode, path + ["save_view"])
            self.write_views = self.__class__.write_views(service, version, mode, path + ["write_views"])
            super().__init__(service, version, mode, path)
        class apply_mirror_planes(TUIMethod):
            """
            .
            """
        class auto_scale(TUIMethod):
            """
            .
            """
        class default_view(TUIMethod):
            """
            .
            """
        class delete_view(TUIMethod):
            """
            .
            """
        class last_view(TUIMethod):
            """
            .
            """
        class list_views(TUIMethod):
            """
            .
            """
        class mirror_zones(TUIMethod):
            """
            .
            """
        class next_view(TUIMethod):
            """
            .
            """
        class read_views(TUIMethod):
            """
            .
            """
        class restore_view(TUIMethod):
            """
            .
            """
        class save_view(TUIMethod):
            """
            .
            """
        class write_views(TUIMethod):
            """
            .
            """

        class camera(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.dolly_camera = self.__class__.dolly_camera(service, version, mode, path + ["dolly_camera"])
                self.field = self.__class__.field(service, version, mode, path + ["field"])
                self.orbit_camera = self.__class__.orbit_camera(service, version, mode, path + ["orbit_camera"])
                self.pan_camera = self.__class__.pan_camera(service, version, mode, path + ["pan_camera"])
                self.position = self.__class__.position(service, version, mode, path + ["position"])
                self.projection = self.__class__.projection(service, version, mode, path + ["projection"])
                self.roll_camera = self.__class__.roll_camera(service, version, mode, path + ["roll_camera"])
                self.target = self.__class__.target(service, version, mode, path + ["target"])
                self.up_vector = self.__class__.up_vector(service, version, mode, path + ["up_vector"])
                self.zoom_camera = self.__class__.zoom_camera(service, version, mode, path + ["zoom_camera"])
                super().__init__(service, version, mode, path)
            class dolly_camera(TUIMethod):
                """
                .
                """
            class field(TUIMethod):
                """
                .
                """
            class orbit_camera(TUIMethod):
                """
                .
                """
            class pan_camera(TUIMethod):
                """
                .
                """
            class position(TUIMethod):
                """
                .
                """
            class projection(TUIMethod):
                """
                .
                """
            class roll_camera(TUIMethod):
                """
                .
                """
            class target(TUIMethod):
                """
                .
                """
            class up_vector(TUIMethod):
                """
                .
                """
            class zoom_camera(TUIMethod):
                """
                .
                """

        class display_states(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.copy = self.__class__.copy(service, version, mode, path + ["copy"])
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                self.new = self.__class__.new(service, version, mode, path + ["new"])
                self.read = self.__class__.read(service, version, mode, path + ["read"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                self.restore_state = self.__class__.restore_state(service, version, mode, path + ["restore_state"])
                self.use_active = self.__class__.use_active(service, version, mode, path + ["use_active"])
                self.write = self.__class__.write(service, version, mode, path + ["write"])
                super().__init__(service, version, mode, path)
            class copy(TUIMethod):
                """
                .
                """
            class create(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class edit(TUIMethod):
                """
                Edit display-states object.
                """
            class list(TUIMethod):
                """
                .
                """
            class list_properties(TUIMethod):
                """
                .
                """
            class make_a_copy(TUIMethod):
                """
                .
                """
            class new(TUIMethod):
                """
                Create a new display-states object.
                """
            class read(TUIMethod):
                """
                .
                """
            class rename(TUIMethod):
                """
                .
                """
            class restore_state(TUIMethod):
                """
                .
                """
            class use_active(TUIMethod):
                """
                .
                """
            class write(TUIMethod):
                """
                .
                """

        class mirror_planes(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.create = self.__class__.create(service, version, mode, path + ["create"])
                self.delete = self.__class__.delete(service, version, mode, path + ["delete"])
                self.edit = self.__class__.edit(service, version, mode, path + ["edit"])
                self.list = self.__class__.list(service, version, mode, path + ["list"])
                self.list_properties = self.__class__.list_properties(service, version, mode, path + ["list_properties"])
                self.make_a_copy = self.__class__.make_a_copy(service, version, mode, path + ["make_a_copy"])
                self.new = self.__class__.new(service, version, mode, path + ["new"])
                self.rename = self.__class__.rename(service, version, mode, path + ["rename"])
                super().__init__(service, version, mode, path)
            class create(TUIMethod):
                """
                .
                """
            class delete(TUIMethod):
                """
                .
                """
            class edit(TUIMethod):
                """
                Edit mirror-planes object.
                """
            class list(TUIMethod):
                """
                .
                """
            class list_properties(TUIMethod):
                """
                .
                """
            class make_a_copy(TUIMethod):
                """
                .
                """
            class new(TUIMethod):
                """
                Create a new mirror-planes object.
                """
            class rename(TUIMethod):
                """
                .
                """

        class rendering_options(TUIMenu):
            """
            .
            """
            def __init__(self, service, version, mode, path):
                self.animation_option = self.__class__.animation_option(service, version, mode, path + ["animation_option"])
                self.auto_spin = self.__class__.auto_spin(service, version, mode, path + ["auto_spin"])
                self.color_map_alignment = self.__class__.color_map_alignment(service, version, mode, path + ["color_map_alignment"])
                self.device_info = self.__class__.device_info(service, version, mode, path + ["device_info"])
                self.double_buffering = self.__class__.double_buffering(service, version, mode, path + ["double_buffering"])
                self.driver = self.__class__.driver(service, version, mode, path + ["driver"])
                self.face_displacement = self.__class__.face_displacement(service, version, mode, path + ["face_displacement"])
                self.front_faces_transparent = self.__class__.front_faces_transparent(service, version, mode, path + ["front_faces_transparent"])
                self.hidden_surface_method = self.__class__.hidden_surface_method(service, version, mode, path + ["hidden_surface_method"])
                self.hidden_surfaces = self.__class__.hidden_surfaces(service, version, mode, path + ["hidden_surfaces"])
                self.set_rendering_options = self.__class__.set_rendering_options(service, version, mode, path + ["set_rendering_options"])
                self.show_colormap = self.__class__.show_colormap(service, version, mode, path + ["show_colormap"])
                super().__init__(service, version, mode, path)
            class animation_option(TUIMethod):
                """
                .
                """
            class auto_spin(TUIMethod):
                """
                .
                """
            class color_map_alignment(TUIMethod):
                """
                .
                """
            class device_info(TUIMethod):
                """
                .
                """
            class double_buffering(TUIMethod):
                """
                .
                """
            class driver(TUIMethod):
                """
                .
                """
            class face_displacement(TUIMethod):
                """
                .
                """
            class front_faces_transparent(TUIMethod):
                """
                .
                """
            class hidden_surface_method(TUIMethod):
                """
                .
                """
            class hidden_surfaces(TUIMethod):
                """
                .
                """
            class set_rendering_options(TUIMethod):
                """
                .
                """
            class show_colormap(TUIMethod):
                """
                .
                """
