docs: def create_url_rules(endpoint, list_route=None, item_route=None,
                       pid_type=None, pid_minter=None, pid_fetcher=None,
                       read_permission_factory_imp=None,
                       create_permission_factory_imp=None,
                       update_permission_factory_imp=None,
                       delete_permission_factory_imp=None,
                       list_permission_factory_imp=None,
                       record_class=None,
                       record_serializers=None,
                       record_serializers_aliases=None,
                       record_loaders=None,
                       search_class=None,
                       indexer_class=RecordIndexer,
                       search_serializers=None,
                       search_index=None, search_type=None,
                       default_media_type=None,
                       max_result_window=None, use_options_view=True,
                       search_factory_imp=None, links_factory_imp=None,
                       suggesters=None, default_endpoint_prefix=None):
      """Create Werkzeug URL rules.
  
      :param endpoint: Name of endpoint.
      :param list_route: Record listing URL route. Required.
      :param item_route: Record URL route (must include ``<pid_value>`` pattern).
          Required.
      :param pid_type: Persistent identifier type for endpoint. Required.
      :param pid_minter: It identifies the registered minter name.
      :param pid_fetcher: It identifies the registered fetcher name.
      :param read_permission_factory_imp: Import path to factory that creates a
          read permission object for a given record.
      :param create_permission_factory_imp: Import path to factory that creates a
          create permission object for a given record.
      :param update_permission_factory_imp: Import path to factory that creates a
          update permission object for a given record.
      :param delete_permission_factory_imp: Import path to factory that creates a
          delete permission object for a given record.
      :param list_permission_factory_imp: Import path to factory that
          creates a list permission object for a given index/list.
      :param default_endpoint_prefix: ignored.
      :param record_class: A record API class or importable string used when
          creating new records.
      :param record_serializers: Serializers used for records.
      :param record_serializers_aliases: A mapping of query arg `format` values
          to valid mimetypes: dict(alias -> mimetype).
      :param record_loaders: It contains the list of record deserializers for
          supperted formats.
      :param search_class: Import path or class object for the object in charge
          of execute the search queries. The default search class is
          :class:`invenio_search.api.RecordsSearch`.
          For more information about resource loading, see the Search of
          ElasticSearch DSL library.
      :param indexer_class: Import path or class object for the object in charge
          of indexing records. The default indexer is
          :class:`invenio_indexer.api.RecordIndexer`.
      :param search_serializers: Serializers used for search results.
      :param search_index: Name of the search index used when searching records.
      :param search_type: Name of the search type used when searching records.
      :param default_media_type: Default media type for both records and search.
      :param max_result_window: Maximum number of results that Elasticsearch can
          provide for the given search index without use of scroll. This value
          should correspond to Elasticsearch ``index.max_result_window`` value
          for the index.
      :param use_options_view: Determines if a special option view should be
          installed.
      :param search_factory_imp: Factory to parse quieries.
      :param links_factory_imp: Factory for record links generation.
      :param suggesters: Suggester fields configuration.
  
      :returns: a list of dictionaries with can each be passed as keywords
          arguments to ``Blueprint.add_url_rule``.
      """
      assert list_route
      assert item_route
      assert pid_type
      assert search_serializers
      assert record_serializers
  
      read_permission_factory = obj_or_import_string(
          read_permission_factory_imp
      )
      create_permission_factory = obj_or_import_string(
          create_permission_factory_imp
      )
      update_permission_factory = obj_or_import_string(
          update_permission_factory_imp
      )
      delete_permission_factory = obj_or_import_string(
          delete_permission_factory_imp
      )
      list_permission_factory = obj_or_import_string(
          list_permission_factory_imp
      )
      links_factory = obj_or_import_string(
          links_factory_imp, default=default_links_factory
      )
      # For backward compatibility. Previous signature was links_factory(pid).
      if wrap_links_factory(links_factory):
          orig_links_factory = links_factory
  
          def links_factory(pid, record=None, **kwargs):
              return orig_links_factory(pid)
  
      record_class = obj_or_import_string(
          record_class, default=Record
      )
      search_class = obj_or_import_string(
          search_class, default=RecordsSearch
      )
  
      indexer_class = obj_or_import_string(
          indexer_class, default=None
      )
  
      search_class_kwargs = {}
      if search_index:
          search_class_kwargs['index'] = search_index
      else:
          search_index = search_class.Meta.index
  
      if search_type:
          search_class_kwargs['doc_type'] = search_type
      else:
          search_type = search_class.Meta.doc_types
  
      if search_class_kwargs:
          search_class = partial(search_class, **search_class_kwargs)
  
      if record_loaders:
          record_loaders = {mime: obj_or_import_string(func)
                            for mime, func in record_loaders.items()}
      record_serializers = {mime: obj_or_import_string(func)
                            for mime, func in record_serializers.items()}
      search_serializers = {mime: obj_or_import_string(func)
                            for mime, func in search_serializers.items()}
  
      list_view = RecordsListResource.as_view(
          RecordsListResource.view_name.format(endpoint),
          minter_name=pid_minter,
          pid_type=pid_type,
          pid_fetcher=pid_fetcher,
          read_permission_factory=read_permission_factory,
          create_permission_factory=create_permission_factory,
          list_permission_factory=list_permission_factory,
          record_serializers=record_serializers,
          record_loaders=record_loaders,
          search_serializers=search_serializers,
          search_class=search_class,
          indexer_class=indexer_class,
          default_media_type=default_media_type,
          max_result_window=max_result_window,
          search_factory=(obj_or_import_string(
              search_factory_imp, default=es_search_factory
          )),
          item_links_factory=links_factory,
          record_class=record_class,
      )
      item_view = RecordResource.as_view(
          RecordResource.view_name.format(endpoint),
          read_permission_factory=read_permission_factory,
          update_permission_factory=update_permission_factory,
          delete_permission_factory=delete_permission_factory,
          serializers=record_serializers,
          serializers_query_aliases=record_serializers_aliases,
          loaders=record_loaders,
          search_class=search_class,
          indexer_class=indexer_class,
          links_factory=links_factory,
          default_media_type=default_media_type)
  
      views = [
          dict(rule=list_route, view_func=list_view),
          dict(rule=item_route, view_func=item_view),
      ]
      if suggesters:
          suggest_view = SuggestResource.as_view(
              SuggestResource.view_name.format(endpoint),
              suggesters=suggesters,
              search_class=search_class,
          )
  
          views.append(dict(
              rule=list_route + '_suggest',
              view_func=suggest_view
          ))
  
      if use_options_view:
          options_view = RecordsListOptionsResource.as_view(
              RecordsListOptionsResource.view_name.format(endpoint),
              search_index=search_index,
              max_result_window=max_result_window,
              default_media_type=default_media_type,
              search_media_types=search_serializers.keys(),
              item_media_types=record_serializers.keys(),
          )
          return [
                     dict(rule="{0}_options".format(list_route),
                          view_func=options_view)
                 ] + views
      return views