"""Wrappers over Meshing queries gRPC service of Fluent."""

from typing import Any, List, Tuple

import grpc

from ansys.api.fluent.v0 import meshing_queries_pb2 as MeshingQueriesProtoModule
from ansys.api.fluent.v0 import meshing_queries_pb2_grpc as MeshingQueriesGrpcModule
from ansys.fluent.core.exceptions import DisallowedValuesError
from ansys.fluent.core.services.error_handler import catch_grpc_error
from ansys.fluent.core.services.interceptors import (
    BatchInterceptor,
    ErrorStateInterceptor,
    TracingInterceptor,
)

Path = List[Tuple[str, str]]


class MeshingQueriesService:
    """Meshing Queries Service."""

    def __init__(
        self, channel: grpc.Channel, metadata: List[Tuple[str, str]], fluent_error_state
    ):
        """__init__ method of MeshingQueriesService class."""
        intercept_channel = grpc.intercept_channel(
            channel,
            ErrorStateInterceptor(fluent_error_state),
            TracingInterceptor(),
            BatchInterceptor(),
        )
        self._stub = MeshingQueriesGrpcModule.MeshingQueriesStub(intercept_channel)
        self._metadata = metadata

    @catch_grpc_error
    def get_face_zone_at_location(
        self, request: MeshingQueriesProtoModule.GetFaceZoneAtLocationRequest
    ) -> MeshingQueriesProtoModule.GetFaceZoneAtLocationResponse:
        """get_face_zone_at_location RPC of MeshingQueriesService."""
        return self._stub.GetFaceZoneAtLocation(request, metadata=self._metadata)

    @catch_grpc_error
    def get_cell_zone_at_location(
        self, request: MeshingQueriesProtoModule.GetCellZoneAtLocationRequest
    ) -> MeshingQueriesProtoModule.GetCellZoneAtLocationResponse:
        """get_cell_zone_at_location RPC of MeshingQueriesService."""
        return self._stub.GetCellZoneAtLocation(request, metadata=self._metadata)

    @catch_grpc_error
    def get_zones_of_type(
        self, request: MeshingQueriesProtoModule.GetZonesOfTypeRequest
    ) -> MeshingQueriesProtoModule.GetZonesOfTypeResponse:
        """get_zones_of_type RPC of MeshingQueriesService."""
        return self._stub.GetZonesOfType(request, metadata=self._metadata)

    @catch_grpc_error
    def get_zones_of_group(
        self, request: MeshingQueriesProtoModule.GetZonesOfGroupRequest
    ) -> MeshingQueriesProtoModule.GetZonesOfGroupResponse:
        """get_zones_of_group RPC of MeshingQueriesService."""
        return self._stub.GetZonesOfGroup(request, metadata=self._metadata)

    @catch_grpc_error
    def get_face_zones_of_filter(
        self, request: MeshingQueriesProtoModule.GetFaceZonesOfFilterRequest
    ) -> MeshingQueriesProtoModule.GetFaceZonesOfFilterResponse:
        """get_face_zones_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetFaceZonesOfFilter(request, metadata=self._metadata)

    @catch_grpc_error
    def get_cell_zones_of_filter(
        self, request: MeshingQueriesProtoModule.GetCellZonesOfFilterRequest
    ) -> MeshingQueriesProtoModule.GetCellZonesOfFilterResponse:
        """get_cell_zones_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetCellZonesOfFilter(request, metadata=self._metadata)

    @catch_grpc_error
    def get_edge_zones_of_filter(
        self, request: MeshingQueriesProtoModule.GetEdgeZonesOfFilterRequest
    ) -> MeshingQueriesProtoModule.GetEdgeZonesOfFilterResponse:
        """get_edge_zones_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetEdgeZonesOfFilter(request, metadata=self._metadata)

    @catch_grpc_error
    def get_node_zones_of_filter(
        self, request: MeshingQueriesProtoModule.GetNodeZonesOfFilterRequest
    ) -> MeshingQueriesProtoModule.GetNodeZonesOfFilterResponse:
        """get_node_zones_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetNodeZonesOfFilter(request, metadata=self._metadata)

    @catch_grpc_error
    def get_objects_of_type(
        self, request: MeshingQueriesProtoModule.GetObjectsOfTypeRequest
    ) -> MeshingQueriesProtoModule.GetObjectsOfTypeResponse:
        """get_objects_of_type RPC of MeshingQueriesService."""
        return self._stub.GetObjectsOfType(request, metadata=self._metadata)

    @catch_grpc_error
    def get_face_zone_id_list_of_object(
        self, request: MeshingQueriesProtoModule.GetFaceZoneIdListOfObjectRequest
    ) -> MeshingQueriesProtoModule.GetFaceZoneIdListOfObjectResponse:
        """get_face_zone_id_list_of_object RPC of MeshingQueriesService."""
        return self._stub.GetFaceZoneIdListOfObject(request, metadata=self._metadata)

    @catch_grpc_error
    def get_edge_zone_id_list_of_object(
        self, request: MeshingQueriesProtoModule.GetEdgeZoneIdListOfObjectRequest
    ) -> MeshingQueriesProtoModule.GetEdgeZoneIdListOfObjectResponse:
        """get_edge_zone_id_list_of_object RPC of MeshingQueriesService."""
        return self._stub.GetEdgeZoneIdListOfObject(request, metadata=self._metadata)

    @catch_grpc_error
    def get_cell_zone_id_list_of_object(
        self, request: MeshingQueriesProtoModule.GetCellZoneIdListOfObjectRequest
    ) -> MeshingQueriesProtoModule.GetCellZoneIdListOfObjectResponse:
        """get_cell_zone_id_list_of_object RPC of MeshingQueriesService."""
        return self._stub.GetCellZoneIdListOfObject(request, metadata=self._metadata)

    @catch_grpc_error
    def get_face_zones_shared_by_regions_of_type(
        self,
        request: MeshingQueriesProtoModule.GetFaceZonesSharedByRegionsOfTypeRequest,
    ) -> MeshingQueriesProtoModule.GetFaceZonesSharedByRegionsOfTypeResponse:
        """get_face_zones_shared_by_regions_of_type RPC of MeshingQueriesService."""
        return self._stub.GetFaceZonesSharedByRegionsOfType(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_face_zones_of_regions(
        self, request: MeshingQueriesProtoModule.GetFaceZonesOfRegionsRequest
    ) -> MeshingQueriesProtoModule.GetFaceZonesOfRegionsResponse:
        """get_face_zones_of_regions RPC of MeshingQueriesService."""
        return self._stub.GetFaceZonesOfRegions(request, metadata=self._metadata)

    @catch_grpc_error
    def get_face_zones_of_labels(
        self, request: MeshingQueriesProtoModule.GetFaceZonesOfLabelsRequest
    ) -> MeshingQueriesProtoModule.GetFaceZonesOfLabelsResponse:
        """get_face_zones_of_labels RPC of MeshingQueriesService."""
        return self._stub.GetFaceZonesOfLabels(request, metadata=self._metadata)

    @catch_grpc_error
    def get_face_zone_id_list_of_labels(
        self,
        request: MeshingQueriesProtoModule.GetFaceZoneIdListOfLabelsRequest,
    ) -> MeshingQueriesProtoModule.GetFaceZoneIdListOfLabelsResponse:
        """get_face_zone_id_list_of_labels RPC of MeshingQueriesService."""
        return self._stub.GetFaceZoneIdListOfLabels(request, metadata=self._metadata)

    @catch_grpc_error
    def get_face_zones_of_objects(
        self, request: MeshingQueriesProtoModule.GetFaceZonesOfObjectsRequest
    ) -> MeshingQueriesProtoModule.GetFaceZonesOfObjectsResponse:
        """get_face_zones_of_objects RPC of MeshingQueriesService."""
        return self._stub.GetFaceZonesOfObjects(request, metadata=self._metadata)

    @catch_grpc_error
    def get_edge_zones_of_objects(
        self, request: MeshingQueriesProtoModule.GetEdgeZonesOfObjectsRequest
    ) -> MeshingQueriesProtoModule.GetEdgeZonesOfObjectsResponse:
        """get_edge_zones_of_objects RPC of MeshingQueriesService."""
        return self._stub.GetEdgeZonesOfObjects(request, metadata=self._metadata)

    @catch_grpc_error
    def get_face_zone_id_list_of_regions(
        self,
        request: MeshingQueriesProtoModule.GetFaceZoneIdListOfRegionsRequest,
    ) -> MeshingQueriesProtoModule.GetFaceZoneIdListOfRegionsResponse:
        """get_face_zone_id_list_of_regions RPC of MeshingQueriesService."""
        return self._stub.GetFaceZoneIdListOfRegions(request, metadata=self._metadata)

    @catch_grpc_error
    def get_prism_cell_zones(
        self,
        request: MeshingQueriesProtoModule.GetPrismCellZonesRequest,
    ) -> MeshingQueriesProtoModule.GetPrismCellZonesResponse:
        """get_prism_cell_zones RPC of MeshingQueriesService."""
        return self._stub.GetPrismCellZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_tet_cell_zones(
        self,
        request: MeshingQueriesProtoModule.GetTetCellZonesRequest,
    ) -> MeshingQueriesProtoModule.GetTetCellZonesResponse:
        """get_tet_cell_zones RPC of MeshingQueriesService."""
        return self._stub.GetTetCellZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_adjacent_cell_zones(
        self,
        request: MeshingQueriesProtoModule.GetAdjacentCellZonesRequest,
    ) -> MeshingQueriesProtoModule.GetAdjacentCellZonesResponse:
        """get_adjacent_cell_zones RPC of MeshingQueriesService."""
        return self._stub.GetAdjacentCellZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_adjacent_face_zones(
        self,
        request: MeshingQueriesProtoModule.GetAdjacentFaceZonesRequest,
    ) -> MeshingQueriesProtoModule.GetAdjacentFaceZonesResponse:
        """get_adjacent_face_zones RPC of MeshingQueriesService."""
        return self._stub.GetAdjacentFaceZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_adjacent_interior_and_boundary_face_zones(
        self,
        request: MeshingQueriesProtoModule.GetAdjacentInteriorAndBoundaryFaceZonesRequest,
    ) -> MeshingQueriesProtoModule.GetAdjacentInteriorAndBoundaryFaceZonesResponse:
        """get_adjacent_interior_and_boundary_face_zones RPC of
        MeshingQueriesService."""
        return self._stub.GetAdjacentInteriorAndBoundaryFaceZones(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_adjacent_zones_by_edge_connectivity(
        self,
        request: MeshingQueriesProtoModule.GetAdjacentZonesByEdgeConnectivityRequest,
    ) -> MeshingQueriesProtoModule.GetAdjacentZonesByEdgeConnectivityResponse:
        """get_adjacent_zones_by_edge_connectivity RPC of MeshingQueriesService."""
        return self._stub.GetAdjacentZonesByEdgeConnectivity(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_adjacent_zones_by_node_connectivity(
        self,
        request: MeshingQueriesProtoModule.GetAdjacentZonesByNodeConnectivityRequest,
    ) -> MeshingQueriesProtoModule.GetAdjacentZonesByNodeConnectivityResponse:
        """get_adjacent_zones_by_node_connectivity RPC of MeshingQueriesService."""
        return self._stub.GetAdjacentZonesByNodeConnectivity(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_shared_boundary_zones(
        self,
        request: MeshingQueriesProtoModule.GetSharedBoundaryZonesRequest,
    ) -> MeshingQueriesProtoModule.GetSharedBoundaryZonesResponse:
        """get_shared_boundary_zones RPC of MeshingQueriesService."""
        return self._stub.GetSharedBoundaryZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_interior_zones_connected_to_cell_zones(
        self,
        request: MeshingQueriesProtoModule.GetInteriorZonesConnectedToCellZonesRequest,
    ) -> MeshingQueriesProtoModule.GetInteriorZonesConnectedToCellZonesResponse:
        """get_interior_zones_connected_to_cell_zones RPC of MeshingQueriesService."""
        return self._stub.GetInteriorZonesConnectedToCellZones(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_face_zones_with_zone_specific_prisms_applied(
        self,
        request: MeshingQueriesProtoModule.Empty,
    ) -> MeshingQueriesProtoModule.GetFaceZonesWithZoneSpecificPrismsAppliedResponse:
        """get_face_zones_with_zone_specific_prisms_applied RPC of
        MeshingQueriesService."""
        return self._stub.GetFaceZonesWithZoneSpecificPrismsApplied(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_face_zones_of_prism_controls(
        self,
        request: MeshingQueriesProtoModule.GetFaceZonesOfPrismControlsRequest,
    ) -> MeshingQueriesProtoModule.GetFaceZonesOfPrismControlsResponse:
        """get_face_zones_of_prism_controls RPC of MeshingQueriesService."""
        return self._stub.GetFaceZonesOfPrismControls(request, metadata=self._metadata)

    @catch_grpc_error
    def get_baffles(
        self,
        request: MeshingQueriesProtoModule.GetBafflesRequest,
    ) -> MeshingQueriesProtoModule.GetBafflesResponse:
        """get_baffles RPC of MeshingQueriesService."""
        return self._stub.GetBaffles(request, metadata=self._metadata)

    @catch_grpc_error
    def get_embedded_baffles(
        self,
        request: MeshingQueriesProtoModule.Empty,
    ) -> MeshingQueriesProtoModule.GetEmbeddedBafflesResponse:
        """get_embedded_baffles RPC of MeshingQueriesService."""
        return self._stub.GetEmbeddedBaffles(request, metadata=self._metadata)

    @catch_grpc_error
    def get_wrapped_zones(
        self,
        request: MeshingQueriesProtoModule.Empty,
    ) -> MeshingQueriesProtoModule.GetWrappedZonesResponse:
        """get_wrapped_zones RPC of MeshingQueriesService."""
        return self._stub.GetWrappedZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_unreferenced_edge_zones(
        self,
        request: MeshingQueriesProtoModule.Empty,
    ) -> MeshingQueriesProtoModule.GetUnreferencedEdgeZonesResponse:
        """get_unreferenced_edge_zones RPC of MeshingQueriesService."""
        return self._stub.GetUnreferencedEdgeZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_unreferenced_face_zones(
        self,
        request: MeshingQueriesProtoModule.Empty,
    ) -> MeshingQueriesProtoModule.GetUnreferencedFaceZonesResponse:
        """get_unreferenced_face_zones RPC of MeshingQueriesService."""
        return self._stub.GetUnreferencedFaceZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_unreferenced_cell_zones(
        self,
        request: MeshingQueriesProtoModule.Empty,
    ) -> MeshingQueriesProtoModule.GetUnreferencedCellZonesResponse:
        """get_unreferenced_cell_zones RPC of MeshingQueriesService."""
        return self._stub.GetUnreferencedCellZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_unreferenced_edge_zones_of_filter(
        self,
        request: MeshingQueriesProtoModule.GetUnreferencedEdgeZonesOfFilterRequest,
    ) -> MeshingQueriesProtoModule.GetUnreferencedEdgeZonesOfFilterResponse:
        """get_unreferenced_edge_zones_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetUnreferencedEdgeZonesOfFilter(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_unreferenced_face_zones_of_filter(
        self,
        request: MeshingQueriesProtoModule.GetUnreferencedFaceZonesOfFilterRequest,
    ) -> MeshingQueriesProtoModule.GetUnreferencedFaceZonesOfFilterResponse:
        """get_unreferenced_face_zones_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetUnreferencedFaceZonesOfFilter(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_unreferenced_cell_zones_of_filter(
        self,
        request: MeshingQueriesProtoModule.GetUnreferencedCellZonesOfFilterRequest,
    ) -> MeshingQueriesProtoModule.GetUnreferencedCellZonesOfFilterResponse:
        """get_unreferenced_cell_zones_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetUnreferencedCellZonesOfFilter(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_unreferenced_edge_zone_id_list_of_pattern(
        self,
        request: MeshingQueriesProtoModule.GetUnreferencedEdgeZoneIdListOfPatternRequest,
    ) -> MeshingQueriesProtoModule.GetUnreferencedEdgeZoneIdListOfPatternResponse:
        """get_unreferenced_edge_zone_id_list_of_pattern RPC of
        MeshingQueriesService."""
        return self._stub.GetUnreferencedEdgeZoneIdListOfPattern(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_unreferenced_face_zone_id_list_of_pattern(
        self,
        request: MeshingQueriesProtoModule.GetUnreferencedFaceZoneIdListOfPatternRequest,
    ) -> MeshingQueriesProtoModule.GetUnreferencedFaceZoneIdListOfPatternResponse:
        """get_unreferenced_face_zone_id_list_of_pattern RPC of
        MeshingQueriesService."""
        return self._stub.GetUnreferencedFaceZoneIdListOfPattern(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_unreferenced_cell_zone_id_list_of_pattern(
        self,
        request: MeshingQueriesProtoModule.GetUnreferencedCellZoneIdListOfPatternRequest,
    ) -> MeshingQueriesProtoModule.GetUnreferencedCellZoneIdListOfPatternResponse:
        """get_unreferenced_cell_zone_id_list_of_pattern RPC of
        MeshingQueriesService."""
        return self._stub.GetUnreferencedCellZoneIdListOfPattern(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_maxsize_cell_zone_by_volume(
        self,
        request: MeshingQueriesProtoModule.GetMaxsizeCellZoneByVolumeRequest,
    ) -> MeshingQueriesProtoModule.GetMaxsizeCellZoneByVolumeResponse:
        """get_maxsize_cell_zone_by_volume RPC of MeshingQueriesService."""
        return self._stub.GetMaxsizeCellZoneByVolume(request, metadata=self._metadata)

    @catch_grpc_error
    def get_maxsize_cell_zone_by_count(
        self,
        request: MeshingQueriesProtoModule.GetMaxsizeCellZoneByCountRequest,
    ) -> MeshingQueriesProtoModule.GetMaxsizeCellZoneByCountResponse:
        """get_maxsize_cell_zone_by_count RPC of MeshingQueriesService."""
        return self._stub.GetMaxsizeCellZoneByCount(request, metadata=self._metadata)

    @catch_grpc_error
    def get_minsize_face_zone_by_area(
        self,
        request: MeshingQueriesProtoModule.GetMinsizeFaceZoneByAreaRequest,
    ) -> MeshingQueriesProtoModule.GetMinsizeFaceZoneByAreaResponse:
        """get_minsize_face_zone_by_area RPC of MeshingQueriesService."""
        return self._stub.GetMinsizeFaceZoneByArea(request, metadata=self._metadata)

    @catch_grpc_error
    def get_minsize_face_zone_by_count(
        self,
        request: MeshingQueriesProtoModule.GetMinsizeFaceZoneByCountRequest,
    ) -> MeshingQueriesProtoModule.GetMinsizeFaceZoneByCountResponse:
        """get_minsize_face_zone_by_count RPC of MeshingQueriesService."""
        return self._stub.GetMinsizeFaceZoneByCount(request, metadata=self._metadata)

    @catch_grpc_error
    def get_face_zone_list_by_maximum_entity_count(
        self,
        request: MeshingQueriesProtoModule.GetFaceZoneListByMaximumEntityCountRequest,
    ) -> MeshingQueriesProtoModule.GetFaceZoneListByMaximumEntityCountResponse:
        """get_face_zone_list_by_maximum_entity_count RPC of MeshingQueriesService."""
        return self._stub.GetFaceZoneListByMaximumEntityCount(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_edge_zone_list_by_maximum_entity_count(
        self,
        request: MeshingQueriesProtoModule.GetEdgeZoneListByMaximumEntityCountRequest,
    ) -> MeshingQueriesProtoModule.GetEdgeZoneListByMaximumEntityCountResponse:
        """get_edge_zone_list_by_maximum_entity_count RPC of MeshingQueriesService."""
        return self._stub.GetEdgeZoneListByMaximumEntityCount(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_cell_zone_list_by_maximum_entity_count(
        self,
        request: MeshingQueriesProtoModule.GetCellZoneListByMaximumEntityCountRequest,
    ) -> MeshingQueriesProtoModule.GetCellZoneListByMaximumEntityCountResponse:
        """get_cell_zone_list_by_maximum_entity_count RPC of MeshingQueriesService."""
        return self._stub.GetCellZoneListByMaximumEntityCount(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_face_zone_list_by_maximum_zone_area(
        self,
        request: MeshingQueriesProtoModule.GetFaceZoneListByMaximumZoneAreaRequest,
    ) -> MeshingQueriesProtoModule.GetFaceZoneListByMaximumZoneAreaResponse:
        """get_face_zone_list_by_maximum_zone_area RPC of MeshingQueriesService."""
        return self._stub.GetFaceZoneListByMaximumZoneArea(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_face_zone_list_by_minimum_zone_area(
        self,
        request: MeshingQueriesProtoModule.GetFaceZoneListByMinimumZoneAreaRequest,
    ) -> MeshingQueriesProtoModule.GetFaceZoneListByMinimumZoneAreaResponse:
        """get_face_zone_list_by_minimum_zone_area RPC of MeshingQueriesService."""
        return self._stub.GetFaceZoneListByMinimumZoneArea(
            request, metadata=self._metadata
        )

    @catch_grpc_error
    def get_zones_with_free_faces(
        self,
        request: MeshingQueriesProtoModule.GetZonesWithFreeFacesRequest,
    ) -> MeshingQueriesProtoModule.GetZonesWithFreeFacesResponse:
        """get_zones_with_free_faces RPC of MeshingQueriesService."""
        return self._stub.GetZonesWithFreeFaces(request, metadata=self._metadata)

    @catch_grpc_error
    def get_zones_with_free_faces(
        self,
        request: MeshingQueriesProtoModule.GetZonesWithFreeFacesRequest,
    ) -> MeshingQueriesProtoModule.GetZonesWithFreeFacesResponse:
        """get_zones_with_free_faces RPC of MeshingQueriesService."""
        return self._stub.GetZonesWithFreeFaces(request, metadata=self._metadata)

    @catch_grpc_error
    def get_zones_with_multi_faces(
        self,
        request: MeshingQueriesProtoModule.GetZonesWithMultiFacesRequest,
    ) -> MeshingQueriesProtoModule.GetZonesWithMultiFacesResponse:
        """get_zones_with_multi_faces RPC of MeshingQueriesService."""
        return self._stub.GetZonesWithMultiFaces(request, metadata=self._metadata)

    @catch_grpc_error
    def get_overlapping_face_zones(
        self,
        request: MeshingQueriesProtoModule.GetOverlappingFaceZonesRequest,
    ) -> MeshingQueriesProtoModule.GetOverlappingFaceZonesResponse:
        """get_overlapping_face_zones RPC of MeshingQueriesService."""
        return self._stub.GetOverlappingFaceZones(request, metadata=self._metadata)

    @catch_grpc_error
    def get_zones_with_multi_faces(
        self,
        request: MeshingQueriesProtoModule.GetZonesWithMultiFacesRequest,
    ) -> MeshingQueriesProtoModule.GetZonesWithMultiFacesResponse:
        """get_zones_with_multi_faces RPC of MeshingQueriesService."""
        return self._stub.GetZonesWithMultiFaces(request, metadata=self._metadata)

    @catch_grpc_error
    def get_zones_with_marked_faces(
        self,
        request: MeshingQueriesProtoModule.GetZonesWithMarkedFacesRequest,
    ) -> MeshingQueriesProtoModule.GetZonesWithMarkedFacesResponse:
        """get_zones_with_marked_faces RPC of MeshingQueriesService."""
        return self._stub.GetZonesWithMarkedFaces(request, metadata=self._metadata)

    @catch_grpc_error
    def get_all_object_name_list(
        self,
        request: MeshingQueriesProtoModule.Empty,
    ) -> MeshingQueriesProtoModule.GetAllObjectNameListResponse:
        """get_all_object_name_list RPC of MeshingQueriesService."""
        return self._stub.GetAllObjectNameList(request, metadata=self._metadata)

    @catch_grpc_error
    def get_object_name_list_of_type(
        self,
        request: MeshingQueriesProtoModule.GetObjectNameListOfTypeRequest,
    ) -> MeshingQueriesProtoModule.GetObjectNameListOfTypeResponse:
        """get_object_name_list_of_type RPC of MeshingQueriesService."""
        return self._stub.GetObjectNameListOfType(request, metadata=self._metadata)

    @catch_grpc_error
    def get_objects_of_filter(
        self,
        request: MeshingQueriesProtoModule.GetObjectsOfFilterRequest,
    ) -> MeshingQueriesProtoModule.GetObjectsOfFilterResponse:
        """get_objects_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetObjectsOfFilter(request, metadata=self._metadata)

    @catch_grpc_error
    def get_regions_of_object(
        self,
        request: MeshingQueriesProtoModule.GetRegionsOfObjectRequest,
    ) -> MeshingQueriesProtoModule.GetRegionsOfObjectResponse:
        """get_regions_of_object RPC of MeshingQueriesService."""
        return self._stub.GetRegionsOfObject(request, metadata=self._metadata)

    @catch_grpc_error
    def get_region_name_list_of_object(
        self,
        request: MeshingQueriesProtoModule.GetRegionNameListOfObjectRequest,
    ) -> MeshingQueriesProtoModule.GetRegionNameListOfObjectResponse:
        """get_region_name_list_of_object RPC of MeshingQueriesService."""
        return self._stub.GetRegionNameListOfObject(request, metadata=self._metadata)

    @catch_grpc_error
    def sort_regions_by_volume(
        self,
        request: MeshingQueriesProtoModule.SortRegionsByVolumeRequest,
    ) -> MeshingQueriesProtoModule.SortRegionsByVolumeResponse:
        """sort_regions_by_volume RPC of MeshingQueriesService."""
        return self._stub.SortRegionsByVolume(request, metadata=self._metadata)

    @catch_grpc_error
    def get_region_volume(
        self,
        request: MeshingQueriesProtoModule.GetRegionVolumeRequest,
    ) -> MeshingQueriesProtoModule.GetRegionVolumeResponse:
        """get_region_volume RPC of MeshingQueriesService."""
        return self._stub.GetRegionVolume(request, metadata=self._metadata)

    @catch_grpc_error
    def get_regions_of_filter(
        self,
        request: MeshingQueriesProtoModule.GetRegionsOfFilterRequest,
    ) -> MeshingQueriesProtoModule.GetRegionsOfFilterResponse:
        """get_regions_of_filter RPC of MeshingQueriesService."""
        return self._stub.GetRegionsOfFilter(request, metadata=self._metadata)

    @catch_grpc_error
    def get_region_name_list_of_pattern(
        self,
        request: MeshingQueriesProtoModule.GetRegionNameListOfPatternRequest,
    ) -> MeshingQueriesProtoModule.GetRegionNameListOfPatternResponse:
        """get_region_name_list_of_pattern RPC of MeshingQueriesService."""
        return self._stub.GetRegionNameListOfPattern(request, metadata=self._metadata)

    @catch_grpc_error
    def get_regions_of_face_zones(
        self,
        request: MeshingQueriesProtoModule.GetRegionsOfFaceZonesRequest,
    ) -> MeshingQueriesProtoModule.GetRegionsOfFaceZonesResponse:
        """get_regions_of_face_zones RPC of MeshingQueriesService."""
        return self._stub.GetRegionsOfFaceZones(request, metadata=self._metadata)

    @catch_grpc_error
    def find_join_pairs(
        self,
        request: MeshingQueriesProtoModule.FindJoinPairsRequest,
    ) -> MeshingQueriesProtoModule.FindJoinPairsResponse:
        """find_join_pairs RPC of MeshingQueriesService."""
        return self._stub.FindJoinPairs(request, metadata=self._metadata)

    @catch_grpc_error
    def get_region_name_list_of_face_zones(
        self,
        request: MeshingQueriesProtoModule.GetRegionNameListOfFaceZonesRequest,
    ) -> MeshingQueriesProtoModule.GetRegionNameListOfFaceZonesResponse:
        """get_region_name_list_of_face_zones RPC of MeshingQueriesService."""
        return self._stub.GetRegionNameListOfFaceZones(request, metadata=self._metadata)


class MeshingQueries:
    """Meshing Queries."""

    def __init__(self, service: MeshingQueriesService):
        """__init__ method of MeshingQueries class."""
        self.service = service
        self.region_types = ["fluid-fluid", "solid-solid", "fluid-solid"]
        self.orders = ["ascending", "descending"]

    docstring = None

    def __get_allowed_region_type(self, region_type):
        """Check region_type in available regions."""
        if region_type not in self.region_types:
            raise DisallowedValuesError("region-type", region_type, self.region_types)

    def _get_allowed_orders(self, order):
        """Check order in available orders."""
        if order not in self.orders:
            raise DisallowedValuesError("order", order, self.orders)

    def get_all_object_name_list(self) -> Any:
        """Return a list of all objects.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_all_object_name_list()
        """
        request = MeshingQueriesProtoModule.Empty()
        response = self.service.get_all_object_name_list(request)
        return response.objects

    def _get_allowed_object(self, object):
        """Check object in available objects."""
        allowed_args = [args for args in self.get_all_object_name_list()]
        if isinstance(object, list):
            for obj in object:
                if obj not in allowed_args:
                    raise DisallowedValuesError("object", obj, allowed_args)
        elif isinstance(object, str) and object not in allowed_args:
            raise DisallowedValuesError("object", object, allowed_args)

    def get_region_name_list_of_object(self, object) -> Any:
        """Return a list of regions in the specified object.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_region_name_list_of_object("elbow-fluid")
        """
        self._get_allowed_object(object)
        request = MeshingQueriesProtoModule.GetRegionNameListOfObjectRequest()
        request.object = object
        response = self.service.get_region_name_list_of_object(request)
        return response.regions

    def _get_allowed_region(self, region):
        """Check region in available regions."""
        objects = [objs for objs in self.get_all_object_name_list()]
        regions = []
        for obj in objects:
            regions.extend(self.get_region_name_list_of_object(obj))
        if isinstance(region, list):
            for reg in region:
                if reg not in regions:
                    raise DisallowedValuesError("region", reg, regions)
        elif isinstance(region, str) and region not in regions:
            raise DisallowedValuesError("region", region, regions)

    def get_face_zone_at_location(self, location) -> Any:
        """Return face zone at or closest to a specified location.

        Note:  This function is not applicable to polyhedral meshes.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zone_at_location([1.4, 1.4, 1.4])
        """
        request = MeshingQueriesProtoModule.GetFaceZoneAtLocationRequest()
        request.location.x = location[0]
        request.location.y = location[1]
        request.location.z = location[2]
        response = self.service.get_face_zone_at_location(request)
        return response.face_zone_id

    def get_cell_zone_at_location(self, location) -> Any:
        """Return cell zone at or closest to a specified location.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_cell_zone_at_location([1.4, 1.4, 1.4])
        """
        request = MeshingQueriesProtoModule.GetCellZoneAtLocationRequest()
        request.location.x = location[0]
        request.location.y = location[1]
        request.location.z = location[2]
        response = self.service.get_cell_zone_at_location(request)
        return response.cell_zone_id

    def get_zones_of_type(self, type) -> Any:
        """Return a list of zones of the specified default zone type.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_zones_of_type("velocity-inlet")
        """
        request = MeshingQueriesProtoModule.GetZonesOfTypeRequest()
        request.type = type
        response = self.service.get_zones_of_type(request)
        return response.zone_ids

    def get_zones_of_group(self, group) -> Any:
        """Return a list of zones of the specified default zone group or user-defined
        group.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_zones_of_group("inlet")
        """
        request = MeshingQueriesProtoModule.GetZonesOfGroupRequest()
        request.group = group
        response = self.service.get_zones_of_group(request)
        return response.zone_ids

    def get_face_zones_of_filter(self, filter) -> Any:
        """Return a list of face zones whose names contain the specified filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zones_of_filter("*")
        """
        request = MeshingQueriesProtoModule.GetFaceZonesOfFilterRequest()
        request.filter = filter
        response = self.service.get_face_zones_of_filter(request)
        return response.face_zone_ids

    def get_cell_zones_of_filter(self, filter) -> Any:
        """Return a list of cell zones whose names contain the specified filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_cell_zones_of_filter("*")
        """
        request = MeshingQueriesProtoModule.GetCellZonesOfFilterRequest()
        request.filter = filter
        response = self.service.get_cell_zones_of_filter(request)
        return response.cell_zone_ids

    def get_edge_zones_of_filter(self, filter) -> Any:
        """Return a list of edge zones whose names contain the specified filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_edge_zones_of_filter("*")
        """
        request = MeshingQueriesProtoModule.GetEdgeZonesOfFilterRequest()
        request.filter = filter
        response = self.service.get_edge_zones_of_filter(request)
        return response.edge_zone_ids

    def get_node_zones_of_filter(self, filter) -> Any:
        """Return a list of node zones whose names contain the specified filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_node_zones_of_filter("*")
        """
        request = MeshingQueriesProtoModule.GetNodeZonesOfFilterRequest()
        request.filter = filter
        response = self.service.get_node_zones_of_filter(request)
        return response.node_zone_ids

    def get_objects_of_type(self, type) -> Any:
        """Return a list of objects of the specified type.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_objects_of_type("mesh")
        """
        request = MeshingQueriesProtoModule.GetObjectsOfTypeRequest()
        request.type = type
        response = self.service.get_objects_of_type(request)
        return response.objects

    def get_face_zone_id_list_of_object(self, object) -> Any:
        """Return a list of face zones by ID in the specified face zone labels of an
        object.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zone_id_list_of_object("elbow-fluid")
        """
        self._get_allowed_object(object)
        request = MeshingQueriesProtoModule.GetFaceZoneIdListOfObjectRequest()
        request.object = object
        response = self.service.get_face_zone_id_list_of_object(request)
        return response.face_zone_ids

    def get_edge_zone_id_list_of_object(self, object) -> Any:
        """Return a list of edge zones by ID in the specified face zone labels of an
        object.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_edge_zone_id_list_of_object("elbow-fluid")
        """
        self._get_allowed_object(object)
        request = MeshingQueriesProtoModule.GetEdgeZoneIdListOfObjectRequest()
        request.object = object
        response = self.service.get_edge_zone_id_list_of_object(request)
        return response.edge_zone_ids

    def get_cell_zone_id_list_of_object(self, object) -> Any:
        """Return a list of cell zones by ID in the specified face zone labels of an
        object.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_cell_zone_id_list_of_object("elbow-fluid")
        """
        self._get_allowed_object(object)
        request = MeshingQueriesProtoModule.GetCellZoneIdListOfObjectRequest()
        request.object = object
        response = self.service.get_cell_zone_id_list_of_object(request)
        return response.cell_zone_ids

    def get_face_zones_shared_by_regions_of_type(self, mesh_object, region_type) -> Any:
        """Return a list of face zones shared by regions of specified types in the mesh
        object specified, where region-type is fluid-fluid, solid-solid, or fluid-solid.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zones_shared_by_regions_of_type("elbow-fluid", "fluid-fluid")
        """
        self._get_allowed_object(mesh_object)
        self.__get_allowed_region_type(region_type)
        request = MeshingQueriesProtoModule.GetFaceZonesSharedByRegionsOfTypeRequest()
        request.mesh_object = mesh_object
        request.region_type = region_type
        response = self.service.get_face_zones_shared_by_regions_of_type(request)
        return response.shared_face_zone_ids

    def get_face_zones_of_regions(self, object, region_name_list) -> Any:
        """Return a list of face zones in the specified regions.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zones_of_regions("elbow-fluid", ["fluid"])
        """
        self._get_allowed_object(object)
        self._get_allowed_region(region_name_list)
        request = MeshingQueriesProtoModule.GetFaceZonesOfRegionsRequest()
        request.object = object
        for region in region_name_list:
            request.regions.append(region)
        response = self.service.get_face_zones_of_regions(request)
        return response.zone_ids

    def get_face_zones_of_labels(self, object, label_name_list) -> Any:
        """Return a list of face zones in the specified face zone labels of the object
        specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zones_of_labels("elbow-fluid", ["inlet", "outlet", "wall", "internal"])
        """
        request = MeshingQueriesProtoModule.GetFaceZonesOfLabelsRequest()
        request.object = object
        for label in label_name_list:
            request.labels.append(label)
        response = self.service.get_face_zones_of_labels(request)
        return response.zone_ids

    def get_face_zone_id_list_of_labels(self, object, zone_label_list) -> Any:
        """Return a list of face zones by ID in the specified face zone labels of an
        object.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zone_id_list_of_labels("elbow-fluid", ["outlet"])
        """
        request = MeshingQueriesProtoModule.GetFaceZoneIdListOfLabelsRequest()
        request.object = object
        for zone_label in zone_label_list:
            request.labels.append(zone_label)
        response = self.service.get_face_zone_id_list_of_labels(request)
        return response.zone_ids

    def get_face_zones_of_objects(self, object_list) -> Any:
        """Return a list of face zones in the specified objects.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zones_of_objects(["elbow-fluid"])
        """
        self._get_allowed_object(object_list)
        request = MeshingQueriesProtoModule.GetFaceZonesOfObjectsRequest()
        for object in object_list:
            request.object_list.append(object)
        response = self.service.get_face_zones_of_objects(request)
        return response.face_zone_ids

    def get_edge_zones_of_objects(self, object_list) -> Any:
        """Return a list of edge zones in the specified objects.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_edge_zones_of_objects(["elbow-fluid"])
        """
        self._get_allowed_object(object_list)
        request = MeshingQueriesProtoModule.GetEdgeZonesOfObjectsRequest()
        for object in object_list:
            request.object_list.append(object)
        response = self.service.get_edge_zones_of_objects(request)
        return response.edge_zone_ids

    def get_face_zone_id_list_of_regions(self, object, region_list) -> Any:
        """Return a list of face zones by ID in the specified regions of an object.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zone_id_list_of_regions("elbow-fluid", ["fluid"])
        """
        self._get_allowed_object(object)
        self._get_allowed_region(region_list)
        request = MeshingQueriesProtoModule.GetFaceZoneIdListOfRegionsRequest()
        request.object = object
        for region in region_list:
            request.labels.append(region)
        response = self.service.get_face_zone_id_list_of_regions(request)
        return response.zone_ids

    def get_prism_cell_zones(self, list_or_pattern) -> Any:
        """Return a list of prism cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_prism_cell_zones(["inlet", "outlet"])

            >>> meshing_session.meshing_queries.get_prism_cell_zones("*")
        """
        request = MeshingQueriesProtoModule.GetPrismCellZonesRequest()
        if isinstance(list_or_pattern, str):
            request.zone_name_or_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            for items in list_or_pattern:
                request.zones.append(items)
        response = self.service.get_prism_cell_zones(request)
        return response.prism_cell_zones

    def get_tet_cell_zones(self, list_or_pattern) -> Any:
        """Return a list of tet cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_tet_cell_zones(["inlet", "outlet"])

            >>> meshing_session.meshing_queries.get_tet_cell_zones("*")
        """
        request = MeshingQueriesProtoModule.GetTetCellZonesRequest()
        if isinstance(list_or_pattern, str):
            request.zone_name_or_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            for items in list_or_pattern:
                request.zones.append(items)
        response = self.service.get_tet_cell_zones(request)
        return response.tet_cell_zones

    def get_adjacent_cell_zones(self, list_or_name_or_pattern) -> Any:
        """Return adjacent cell zones for given face zone.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_adjacent_cell_zones([30])

            >>> meshing_session.meshing_queries.get_adjacent_cell_zones("*")
        """
        request = MeshingQueriesProtoModule.GetAdjacentCellZonesRequest()
        if isinstance(list_or_name_or_pattern, str):
            request.zone_name_or_pattern = list_or_name_or_pattern
        elif isinstance(list_or_name_or_pattern, list):
            for items in list_or_name_or_pattern:
                request.face_zone_ids.append(items)
        response = self.service.get_adjacent_cell_zones(request)
        return response.adjacent_cell_zones

    def get_adjacent_face_zones(self, list_or_name_or_pattern) -> Any:
        """Return adjacent boundary face zones for given cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_adjacent_face_zones([3460])

            >>> meshing_session.meshing_queries.get_adjacent_face_zones("*")
        """
        request = MeshingQueriesProtoModule.GetAdjacentFaceZonesRequest()
        if isinstance(list_or_name_or_pattern, str):
            request.zone_name_or_pattern = list_or_name_or_pattern
        elif isinstance(list_or_name_or_pattern, list):
            for items in list_or_name_or_pattern:
                request.cell_zone_ids.append(items)
        response = self.service.get_adjacent_face_zones(request)
        return response.adjacent_boundary_face_zones

    def get_adjacent_interior_and_boundary_face_zones(
        self, list_or_name_or_pattern
    ) -> Any:
        """Return adjacent interior and boundary face zones for given cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_adjacent_interior_and_boundary_face_zones([30])

            >>> meshing_session.meshing_queries.get_adjacent_interior_and_boundary_face_zones("fluid")

            >>> meshing_session.meshing_queries.get_adjacent_interior_and_boundary_face_zones("*")
        """
        request = (
            MeshingQueriesProtoModule.GetAdjacentInteriorAndBoundaryFaceZonesRequest()
        )
        if isinstance(list_or_name_or_pattern, str):
            request.zone_name_or_pattern = list_or_name_or_pattern
        elif isinstance(list_or_name_or_pattern, list):
            for items in list_or_name_or_pattern:
                request.cell_zone_ids.append(items)
        response = self.service.get_adjacent_interior_and_boundary_face_zones(request)
        return response.adjacent_interior_and_boundary_face_zones

    def get_adjacent_zones_by_edge_connectivity(self, list_or_name_or_pattern) -> Any:
        """Return adjacent zones based on edge connectivity.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_adjacent_zones_by_edge_connectivity([30])

            >>> meshing_session.meshing_queries.get_adjacent_zones_by_edge_connectivity("*")
        """
        request = MeshingQueriesProtoModule.GetAdjacentZonesByEdgeConnectivityRequest()
        if isinstance(list_or_name_or_pattern, str):
            request.zone_name_or_pattern = list_or_name_or_pattern
        elif isinstance(list_or_name_or_pattern, list):
            for items in list_or_name_or_pattern:
                request.zone_ids.append(items)
        response = self.service.get_adjacent_zones_by_edge_connectivity(request)
        return response.adjacent_zone_ids

    def get_adjacent_zones_by_node_connectivity(self, list_or_name_or_pattern) -> Any:
        """Return adjacent zones based on node connectivity.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_adjacent_zones_by_node_connectivity([30])

            >>> meshing_session.meshing_queries.get_adjacent_zones_by_node_connectivity("*")
        """
        request = MeshingQueriesProtoModule.GetAdjacentZonesByNodeConnectivityRequest()
        if isinstance(list_or_name_or_pattern, str):
            request.zone_name_or_pattern = list_or_name_or_pattern
        elif isinstance(list_or_name_or_pattern, list):
            for items in list_or_name_or_pattern:
                request.zone_ids.append(items)
        response = self.service.get_adjacent_zones_by_node_connectivity(request)
        return response.adjacent_zone_ids

    def get_shared_boundary_zones(self, list_or_name_or_pattern) -> Any:
        """Returns the number of faces and the boundary face zones that are shared with
        the specified cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_shared_boundary_zones("*")

            >>> meshing_session.meshing_queries.get_shared_boundary_zones([3460])
        """
        request = MeshingQueriesProtoModule.GetSharedBoundaryZonesRequest()
        if isinstance(list_or_name_or_pattern, str):
            request.cell_zone_name_or_pattern = list_or_name_or_pattern
        elif isinstance(list_or_name_or_pattern, list):
            for items in list_or_name_or_pattern:
                request.cell_zone_ids.append(items)
        response = self.service.get_shared_boundary_zones(request)
        return response.shared_boundary_zone_ids

    def get_interior_zones_connected_to_cell_zones(
        self, list_or_name_or_pattern
    ) -> Any:
        """Returns interior face zones connected to given cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_interior_zones_connected_to_cell_zones([3460])

            >>> meshing_session.meshing_queries.get_interior_zones_connected_to_cell_zones("*")
        """
        request = (
            MeshingQueriesProtoModule.GetInteriorZonesConnectedToCellZonesRequest()
        )
        if isinstance(list_or_name_or_pattern, str):
            request.cell_zone_name_or_pattern = list_or_name_or_pattern
        elif isinstance(list_or_name_or_pattern, list):
            for items in list_or_name_or_pattern:
                request.face_zone_ids.append(items)
        response = self.service.get_interior_zones_connected_to_cell_zones(request)
        return response.interior_zone_ids

    def get_face_zones_with_zone_specific_prisms_applied(self) -> Any:
        """Return a list of face zones with zone-specific prism settings applied.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zones_with_zone_specific_prisms_applied()
        """
        request = MeshingQueriesProtoModule.Empty()
        response = self.service.get_face_zones_with_zone_specific_prisms_applied(
            request
        )
        return response.face_zone_ids

    def get_face_zones_of_prism_controls(self, control_name) -> Any:
        """Return a list of face zones to which the specified prism controls apply.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zones_of_prism_controls("*")
        """
        request = MeshingQueriesProtoModule.GetFaceZonesOfPrismControlsRequest()
        request.control_name = control_name
        response = self.service.get_face_zones_of_prism_controls(request)
        return response.face_zone_ids

    def get_baffles(self, face_zone_list) -> Any:
        """Return the baffle zones based on the face zone list specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_baffles([29, 30])
        """
        request = MeshingQueriesProtoModule.GetBafflesRequest()
        for items in face_zone_list:
            request.face_zone_ids.append(items)
        response = self.service.get_baffles(request)
        return response.baffle_zone_ids

    def get_embedded_baffles(self) -> Any:
        """Return the embedded baffle zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_embedded_baffles()
        """
        request = MeshingQueriesProtoModule.Empty()
        response = self.service.get_embedded_baffles(request)
        return response.embedded_baffles_zone_ids

    def get_wrapped_zones(self) -> Any:
        """Return a list of wrapped face zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_wrapped_zones()
        """
        request = MeshingQueriesProtoModule.Empty()
        response = self.service.get_wrapped_zones(request)
        return response.wrapped_face_zone_ids

    def get_unreferenced_edge_zones(self) -> Any:
        """Return a list of unreferenced edge zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_edge_zones()
        """
        request = MeshingQueriesProtoModule.Empty()
        response = self.service.get_unreferenced_edge_zones(request)
        return response.unreferenced_edge_zone_ids

    def get_unreferenced_face_zones(self) -> Any:
        """Return a list of unreferenced face zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_face_zones()
        """
        request = MeshingQueriesProtoModule.Empty()
        response = self.service.get_unreferenced_face_zones(request)
        return response.unreferenced_face_zone_ids

    def get_unreferenced_cell_zones(self) -> Any:
        """Return a list of unreferenced cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_cell_zones()
        """
        request = MeshingQueriesProtoModule.Empty()
        response = self.service.get_unreferenced_cell_zones(request)
        return response.unreferenced_cell_zone_ids

    def get_unreferenced_edge_zones_of_filter(self, filter) -> Any:
        """Return a list of unreferenced edge zones whose names contain the specified
        filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_edge_zones_of_filter("*")
        """
        request = MeshingQueriesProtoModule.GetUnreferencedEdgeZonesOfFilterRequest()
        request.filter = filter
        response = self.service.get_unreferenced_edge_zones_of_filter(request)
        return response.unreferenced_edge_zone_ids

    def get_unreferenced_face_zones_of_filter(self, filter) -> Any:
        """Return a list of unreferenced face zones whose names contain the specified
        filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_face_zones_of_filter("*")
        """
        request = MeshingQueriesProtoModule.GetUnreferencedFaceZonesOfFilterRequest()
        request.filter = filter
        response = self.service.get_unreferenced_face_zones_of_filter(request)
        return response.unreferenced_face_zone_ids

    def get_unreferenced_cell_zones_of_filter(self, filter) -> Any:
        """Return a list of unreferenced cell zones whose names contain the specified
        filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_cell_zones_of_filter("*")
        """
        request = MeshingQueriesProtoModule.GetUnreferencedCellZonesOfFilterRequest()
        request.filter = filter
        response = self.service.get_unreferenced_cell_zones_of_filter(request)
        return response.unreferenced_cell_zone_ids

    def get_unreferenced_edge_zone_id_list_of_pattern(self, pattern) -> Any:
        """Return a list of unreferenced edge zones by ID, whose names contain the
        specified pattern.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_edge_zone_id_list_of_pattern("*")
        """
        request = (
            MeshingQueriesProtoModule.GetUnreferencedEdgeZoneIdListOfPatternRequest()
        )
        request.pattern = pattern
        response = self.service.get_unreferenced_edge_zone_id_list_of_pattern(request)
        return response.unreferenced_edge_zone_ids

    def get_unreferenced_face_zone_id_list_of_pattern(self, pattern) -> Any:
        """Return a list of unreferenced face zones by ID, whose names contain the
        specified pattern.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_face_zone_id_list_of_pattern("*")
        """
        request = (
            MeshingQueriesProtoModule.GetUnreferencedFaceZoneIdListOfPatternRequest()
        )
        request.pattern = pattern
        response = self.service.get_unreferenced_face_zone_id_list_of_pattern(request)
        return response.unreferenced_face_zone_ids

    def get_unreferenced_cell_zone_id_list_of_pattern(self, pattern) -> Any:
        """Return a list of unreferenced cell zones by ID, whose names contain the
        specified pattern.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_unreferenced_cell_zone_id_list_of_pattern("*")
        """
        request = (
            MeshingQueriesProtoModule.GetUnreferencedCellZoneIdListOfPatternRequest()
        )
        request.pattern = pattern
        response = self.service.get_unreferenced_cell_zone_id_list_of_pattern(request)
        return response.unreferenced_cell_zone_ids

    def get_maxsize_cell_zone_by_volume(self, list_or_pattern) -> Any:
        """Return cell zone with maximum volume for given list or pattern of cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_maxsize_cell_zone_by_volume("*")

            >>> meshing_session.meshing_queries.get_maxsize_cell_zone_by_volume([3460])
        """
        request = MeshingQueriesProtoModule.GetMaxsizeCellZoneByVolumeRequest()
        if isinstance(list_or_pattern, str):
            request.cell_zone_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            if isinstance(list_or_pattern[0], int):
                for items in list_or_pattern:
                    request.cell_zone_ids.append(items)
            elif isinstance(list_or_pattern[0], str):
                for items in list_or_pattern:
                    request.cell_zone_names.append(items)
        response = self.service.get_maxsize_cell_zone_by_volume(request)
        return response.cell_zone_id

    def get_maxsize_cell_zone_by_count(self, list_or_pattern) -> Any:
        """Return cell zone with maximum count of elements for given list or pattern of
        cell zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_maxsize_cell_zone_by_count("*")

            >>> meshing_session.meshing_queries.get_maxsize_cell_zone_by_count([3460])
        """
        request = MeshingQueriesProtoModule.GetMaxsizeCellZoneByCountRequest()
        if isinstance(list_or_pattern, str):
            request.cell_zone_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            if isinstance(list_or_pattern[0], int):
                for items in list_or_pattern:
                    request.cell_zone_ids.append(items)
            elif isinstance(list_or_pattern[0], str):
                for items in list_or_pattern:
                    request.cell_zone_names.append(items)
        response = self.service.get_maxsize_cell_zone_by_count(request)
        return response.cell_zone_id

    def get_minsize_face_zone_by_area(self, list_or_pattern) -> Any:
        """Return face zone with minimum area for given list or pattern of face zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_minsize_face_zone_by_area("*")

            >>> meshing_session.meshing_queries.get_minsize_face_zone_by_area([29, 30, 31, 32, 33, 34])
        """
        request = MeshingQueriesProtoModule.GetMinsizeFaceZoneByAreaRequest()
        if isinstance(list_or_pattern, str):
            request.face_zone_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            if isinstance(list_or_pattern[0], int):
                for items in list_or_pattern:
                    request.face_zone_ids.append(items)
            elif isinstance(list_or_pattern[0], str):
                for items in list_or_pattern:
                    request.face_zone_names.append(items)
        response = self.service.get_minsize_face_zone_by_area(request)
        return response.face_zone_id

    def get_minsize_face_zone_by_count(self, list_or_pattern) -> Any:
        """Return face zone with minimum count of elements for given list or pattern of
        face zones.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_minsize_face_zone_by_count("*")

            >>> meshing_session.meshing_queries.get_minsize_face_zone_by_count([29, 30, 31, 32, 33, 34])
        """
        request = MeshingQueriesProtoModule.GetMinsizeFaceZoneByCountRequest()
        if isinstance(list_or_pattern, str):
            request.face_zone_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            if isinstance(list_or_pattern[0], int):
                for items in list_or_pattern:
                    request.face_zone_ids.append(items)
            elif isinstance(list_or_pattern[0], str):
                for items in list_or_pattern:
                    request.face_zone_names.append(items)
        response = self.service.get_minsize_face_zone_by_count(request)
        return response.face_zone_id

    def get_face_zone_list_by_maximum_entity_count(
        self, max_entity_count, only_boundary
    ) -> Any:
        """Return a list of face zones with a count below the maximum entity count
        (maximum-entity-count) specified. You can choose to restrict the report to only
        boundary edge zones, if required (only-boundary? set to True or False).

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zone_list_by_maximum_entity_count(20, True)
        """
        request = MeshingQueriesProtoModule.GetFaceZoneListByMaximumEntityCountRequest()
        request.maximum_entity_count = max_entity_count
        request.only_boundary = only_boundary
        response = self.service.get_face_zone_list_by_maximum_entity_count(request)
        return response.face_zone_ids

    def get_edge_zone_list_by_maximum_entity_count(
        self, max_entity_count, only_boundary
    ) -> Any:
        """Return a list of edge zones with a count below the maximum entity count
        (maximum-entity-count) specified. You can choose to restrict the report to only
        boundary edge zones, if required (only-boundary? set to True or False).

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_edge_zone_list_by_maximum_entity_count(20, False)
        """
        request = MeshingQueriesProtoModule.GetEdgeZoneListByMaximumEntityCountRequest()
        request.maximum_entity_count = max_entity_count
        request.only_boundary = only_boundary
        response = self.service.get_edge_zone_list_by_maximum_entity_count(request)
        return response.edge_zone_ids

    def get_cell_zone_list_by_maximum_entity_count(self, maximum_entity_count) -> Any:
        """Return a list of cell zones with a count below the maximum entity count
        (maximum-entity-count) specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_cell_zone_list_by_maximum_entity_count(1)
        """
        request = MeshingQueriesProtoModule.GetCellZoneListByMaximumEntityCountRequest()
        request.maximum_entity_count = maximum_entity_count
        response = self.service.get_cell_zone_list_by_maximum_entity_count(request)
        return response.cell_zone_ids

    def get_face_zone_list_by_maximum_zone_area(self, maximum_zone_area) -> Any:
        """Return a list of face zones with a maximum zone area below the maximum-zone-
        area specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zone_list_by_maximum_zone_area(100)
        """
        request = MeshingQueriesProtoModule.GetFaceZoneListByMaximumZoneAreaRequest()
        request.maximum_zone_area = maximum_zone_area
        response = self.service.get_face_zone_list_by_maximum_zone_area(request)
        return response.face_zone_ids

    def get_face_zone_list_by_minimum_zone_area(self, minimum_zone_area) -> Any:
        """Return a list of face zones with a minimum zone area above the minimum-zone-
        area specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_face_zone_list_by_minimum_zone_area(10)
        """
        request = MeshingQueriesProtoModule.GetFaceZoneListByMinimumZoneAreaRequest()
        request.minimum_zone_area = minimum_zone_area
        response = self.service.get_face_zone_list_by_minimum_zone_area(request)
        return response.face_zone_ids

    def get_zones_with_free_faces(self, list_or_pattern) -> Any:
        """Return a list of zones with free faces for the face zones specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_zones_with_free_faces("*")

            >>> meshing_session.meshing_queries.get_zones_with_free_faces([29, 30, 31, 32])

            >>> meshing_session.meshing_queries.get_zones_with_free_faces(["inlet", "outlet"])
        """
        request = MeshingQueriesProtoModule.GetZonesWithFreeFacesRequest()
        if isinstance(list_or_pattern, str):
            request.face_zone_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            if isinstance(list_or_pattern[0], int):
                for items in list_or_pattern:
                    request.face_zone_ids.append(items)
            elif isinstance(list_or_pattern[0], str):
                for items in list_or_pattern:
                    request.face_zone_names.append(items)
        response = self.service.get_zones_with_free_faces(request)
        return response.zones_with_free_faces

    def get_zones_with_multi_faces(self, list_or_pattern) -> Any:
        """Return a list of zones with multi-connected faces for the face zones
        specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_zones_with_multi_faces("*")

            >>> meshing_session.meshing_queries.get_zones_with_multi_faces([29, 30, 31, 32])

            >>> meshing_session.meshing_queries.get_zones_with_multi_faces(["inlet", "outlet"])
        """
        request = MeshingQueriesProtoModule.GetZonesWithMultiFacesRequest()
        if isinstance(list_or_pattern, str):
            request.face_zone_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            if isinstance(list_or_pattern[0], int):
                for items in list_or_pattern:
                    request.face_zone_ids.append(items)
            elif isinstance(list_or_pattern[0], str):
                for items in list_or_pattern:
                    request.face_zone_names.append(items)
        response = self.service.get_zones_with_multi_faces(request)
        return response.zones_with_multi_connected_faces

    def get_overlapping_face_zones(
        self, zone_name_pattern, area_tolerance, distance_tolerance
    ) -> Any:
        """Return a list of overlapping face zones based on the area-tolerance and
        distance-tolerance specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.GetOverlappingFaceZones("*", 0.1, 0.1)
        """
        request = MeshingQueriesProtoModule.GetOverlappingFaceZonesRequest()
        request.face_zone_name_or_pattern = zone_name_pattern
        request.area_tolerance = area_tolerance
        request.distance_tolerance = distance_tolerance
        response = self.service.get_overlapping_face_zones(request)
        return response.overlapping_face_zone_ids

    def get_zones_with_marked_faces(self, list_or_pattern) -> Any:
        """Return a list of zones with marked faces for the face zones specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_zones_with_marked_faces("*")

            >>> meshing_session.meshing_queries.get_zones_with_marked_faces([29, 30, 31, 32])

            >>> meshing_session.meshing_queries.get_zones_with_marked_faces(["inlet", "outlet"])
        """
        request = MeshingQueriesProtoModule.GetZonesWithMarkedFacesRequest()
        if isinstance(list_or_pattern, str):
            request.face_zone_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            if isinstance(list_or_pattern[0], int):
                for items in list_or_pattern:
                    request.face_zone_ids.append(items)
            elif isinstance(list_or_pattern[0], str):
                for items in list_or_pattern:
                    request.face_zone_names.append(items)
        response = self.service.get_zones_with_marked_faces(request)
        return response.zones_with_marked_faces

    def get_object_name_list_of_type(self, type) -> Any:
        """Return a list of objects of the specified type.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_object_name_list_of_type("mesh")
        """
        request = MeshingQueriesProtoModule.GetObjectNameListOfTypeRequest()
        request.type = type
        response = self.service.get_object_name_list_of_type(request)
        return response.objects

    def get_objects_of_filter(self, filter) -> Any:
        """Return a list of objects whose names contain the specified filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_objects_of_filter("*")
        """
        request = MeshingQueriesProtoModule.GetObjectsOfFilterRequest()
        request.filter = filter
        response = self.service.get_objects_of_filter(request)
        return response.objects

    def get_regions_of_object(self, object) -> Any:
        """Return a list of regions in the specified object.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_regions_of_object("elbow-fluid")
        """
        self._get_allowed_object(object)
        request = MeshingQueriesProtoModule.GetRegionsOfObjectRequest()
        request.object = object
        response = self.service.get_regions_of_object(request)
        return response.regions

    def sort_regions_by_volume(self, object_name, order) -> Any:
        """Returns a sorted list of volumetric regions by volume for the object
        specified. Specify the order (ascending or descending).

        .. code-block:: python

            >>> meshing_session.meshing_queries.sort_regions_by_volume("elbow-fluid", "ascending")
        """
        self._get_allowed_object(object_name)
        self._get_allowed_orders(order)
        request = MeshingQueriesProtoModule.SortRegionsByVolumeRequest()
        request.object_name = object_name
        request.order = order
        response = self.service.sort_regions_by_volume(request)
        return response.regions

    def get_region_volume(self, object_name, region_name) -> Any:
        """Return the region volume for the specified region of an object.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_region_volume("elbow-fluid", "fluid")
        """
        self._get_allowed_object(object_name)
        self._get_allowed_region(region_name)
        request = MeshingQueriesProtoModule.GetRegionVolumeRequest()
        request.object_name = object_name
        request.region_name = region_name
        response = self.service.get_region_volume(request)
        return response.region_volume

    def get_regions_of_filter(self, object, filter) -> Any:
        """Return a list of regions in the specified object, whose names contain the
        specified filter string.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_regions_of_filter("elbow-fluid", "*")
        """
        request = MeshingQueriesProtoModule.GetRegionsOfFilterRequest()
        request.object = object
        request.filter = filter
        response = self.service.get_regions_of_filter(request)
        return response.regions

    def get_region_name_list_of_pattern(self, object, region_name_or_pattern) -> Any:
        """Return a list of regions in the specified object, whose names contain the
        specified name pattern.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_region_name_list_of_pattern("elbow-fluid", "*")
        """
        request = MeshingQueriesProtoModule.GetRegionNameListOfPatternRequest()
        request.object = object
        request.region_name_or_pattern = region_name_or_pattern
        response = self.service.get_region_name_list_of_pattern(request)
        return response.regions

    def get_regions_of_face_zones(self, list_of_face_zone_ids) -> Any:
        """Return a list of regions containing the face zones specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_regions_of_face_zones([29, 30, 31, 32, 33, 34])
        """
        request = MeshingQueriesProtoModule.GetRegionsOfFaceZonesRequest()
        for id in list_of_face_zone_ids:
            request.face_zone_ids.append(id)
        response = self.service.get_regions_of_face_zones(request)
        return response.regions

    def find_join_pairs(
        self, face_zone_list_or_pattern, join_tolerance, absolute_tolerance, join_angle
    ) -> Any:
        """Return the pairs of overlapping face zones based on the join tolerance and
        feature angle.

        .. code-block:: python

            >>> meshing_session.meshing_queries.find_join_pairs("outlet", 0.1, True, 40)

            >>> meshing_session.meshing_queries.find_join_pairs([32], 0.1, True, 40))

            >>> meshing_session.meshing_queries.find_join_pairs(["outlet"], 0.1, True, 40)
        """
        request = MeshingQueriesProtoModule.FindJoinPairsRequest()
        if isinstance(face_zone_list_or_pattern, str):
            request.face_zone_name_or_pattern = face_zone_list_or_pattern
        elif isinstance(face_zone_list_or_pattern, list):
            if isinstance(face_zone_list_or_pattern[0], int):
                for items in face_zone_list_or_pattern:
                    request.face_zone_ids.append(items)
            elif isinstance(face_zone_list_or_pattern[0], str):
                for items in face_zone_list_or_pattern:
                    request.face_zone_names.append(items)
        request.join_tolerance = join_tolerance
        request.absolute_tolerance = absolute_tolerance
        request.join_angle = join_angle
        response = self.service.find_join_pairs(request)
        return response.pairs

    def get_region_name_list_of_face_zones(self, list_or_pattern) -> Any:
        """Return a list of regions containing the face zones specified.

        .. code-block:: python

            >>> meshing_session.meshing_queries.get_region_name_list_of_face_zones([29, 30, 31, 32, 33, 34])
        """
        request = MeshingQueriesProtoModule.GetRegionNameListOfFaceZonesRequest()
        if isinstance(list_or_pattern, str):
            request.face_zone_name_or_pattern = list_or_pattern
        elif isinstance(list_or_pattern, list):
            for items in list_or_pattern:
                request.face_zone_ids.append(items)
        response = self.service.get_region_name_list_of_face_zones(request)
        return response.regions
