def METHOD_NAME(self, node: ast.ClassDef):
    route_args_dict: Dict[str, RouteArgEntry] = dict()
    can_check_route_args = False
    has_documented_route = False  # If there's at least one route that should be documented for this class
    has_class_level_expect = False
    methods_with_ids = []
    for decorator in node.decorator_list:
        if isinstance(decorator, ast.Call):
            # @api.route() decorators
            if is_route_decorator(decorator) and is_route_decorator_documented(
                decorator
            ):
                has_documented_route = True
                if parse_route_args(decorator, route_args_dict):
                    can_check_route_args = True
                methods_with_ids.extend(
                    find_and_process_route_doc(decorator, route_args_dict)
                )
            elif is_api_expect_decorator(decorator):
                has_class_level_expect = True
    # Skip undocumented routes or non-resource classes
    if not has_documented_route:
        self.generic_visit(node)
        return
    for child in node.body:
        if isinstance(child, ast.FunctionDef) and child.name in ROUTE_HTTP_METHODS:
            processed_decorators: List[str] = []
            for decorator in child.decorator_list:
                # Callable decorators
                if isinstance(decorator, ast.Call):
                    # Namespaced decorators (eg. @api.doc() or @api.expect() or @api.marshal_with())
                    if isinstance(decorator.func, ast.Attribute):
                        self._check_decorator_order(
                            decorator.func.attr,
                            processed_decorators,
                            (decorator.lineno, decorator.col_offset),
                        )
                        if decorator.func.attr == "doc":
                            processed_keywords: List[str] = []
                            for keyword in decorator.keywords:
                                if can_check_route_args:
                                    self._check_doc_params_only_routes(
                                        keyword, route_args_dict
                                    )
                                if keyword.arg:
                                    self._check_doc_keyword_order(
                                        keyword, processed_keywords
                                    )
                                if keyword.arg == "id":
                                    methods_with_ids.append(child.name)
                    # Function decorators (eg. @cache())
                    elif isinstance(decorator.func, ast.Name):
                        self._check_decorator_order(
                            decorator.func.id,
                            processed_decorators,
                            (decorator.lineno, decorator.col_offset),
                        )
                # Name-only decorators (eg. @record_metrics)
                elif isinstance(decorator, ast.Name):
                    self._check_decorator_order(
                        decorator.id,
                        processed_decorators,
                        (decorator.lineno, decorator.col_offset),
                    )
            # Check that method has a custom id
            if child.name not in methods_with_ids:
                self.problems.append(
                    (
                        child.lineno,
                        child.col_offset,
                        "FDP005",
                        [child.name],
                    )
                )
    # Skip check if there's a toplevel @api.expect() as that could document them.
    if not has_class_level_expect:
        self._check_route_args_have_descriptions(route_args_dict)
    self.generic_visit(node)