django-stubs/django-stubs-generated/urls/resolvers.pyi

from collections import OrderedDict
from typing import Any, Callable, Dict, List, Optional, Tuple, Type, Union

from django.contrib.flatpages.sitemaps import FlatPageSitemap
from django.contrib.sitemaps import Sitemap
from django.core.checks.messages import CheckMessage, Warning
from django.urls.converters import UUIDConverter
from django.utils.datastructures import MultiValueDict


class ResolverMatch:
    func: Callable = ...
    args: Tuple = ...
    kwargs: Dict[str, Any] = ...
    url_name: Optional[str] = ...
    app_names: List[str] = ...
    app_name: str = ...
    namespaces: List[str] = ...
    namespace: str = ...
    view_name: str = ...
    def __init__(
        self,
        func: Callable,
        args: Tuple,
        kwargs: Dict[str, Any],
        url_name: Optional[str] = ...,
        app_names: Optional[List[Optional[str]]] = ...,
        namespaces: Optional[List[Optional[str]]] = ...,
    ) -> None: ...
    def __getitem__(self, index: int) -> Any: ...

def get_resolver(
    urlconf: Optional[Union[Type[Any], str]] = ...
) -> URLResolver: ...
def get_ns_resolver(
    ns_pattern: str, resolver: URLResolver, converters: Tuple
) -> URLResolver: ...

class LocaleRegexDescriptor:
    attr: str = ...
    def __init__(self, attr: Any) -> None: ...
    def __get__(
        self, instance: Optional[RegexPattern], cls: Type[RegexPattern] = ...
    ) -> LocaleRegexDescriptor: ...

class CheckURLMixin:
    def describe(self) -> str: ...

class RegexPattern(CheckURLMixin):
    regex: Any = ...
    name: Optional[str] = ...
    converters: Dict[Any, Any] = ...
    def __init__(
        self, regex: str, name: Optional[str] = ..., is_endpoint: bool = ...
    ) -> None: ...
    def match(
        self, path: str
    ) -> Optional[Tuple[str, Tuple, Dict[str, str]]]: ...
    def check(self) -> List[Warning]: ...

class RoutePattern(CheckURLMixin):
    regex: Any = ...
    name: Optional[str] = ...
    converters: Dict[str, UUIDConverter] = ...
    def __init__(
        self, route: str, name: Optional[str] = ..., is_endpoint: bool = ...
    ) -> None: ...
    def match(
        self, path: str
    ) -> Optional[Tuple[str, Tuple, Dict[str, Union[int, str]]]]: ...
    def check(self) -> List[Warning]: ...

class LocalePrefixPattern:
    prefix_default_language: bool = ...
    converters: Dict[Any, Any] = ...
    def __init__(self, prefix_default_language: bool = ...) -> None: ...
    @property
    def regex(self): ...
    @property
    def language_prefix(self) -> str: ...
    def match(
        self, path: str
    ) -> Optional[Tuple[str, Tuple, Dict[Any, Any]]]: ...
    def check(self) -> List[Any]: ...
    def describe(self) -> str: ...

class URLPattern:
    lookup_str: str
    pattern: django.urls.resolvers.CheckURLMixin = ...
    callback: Callable = ...
    default_args: Dict[
        str,
        Union[
            Dict[str, Type[django.contrib.flatpages.sitemaps.FlatPageSitemap]],
            Dict[str, django.contrib.sitemaps.Sitemap],
            collections.OrderedDict,
            str,
        ],
    ] = ...
    name: Optional[str] = ...
    def __init__(
        self,
        pattern: CheckURLMixin,
        callback: Callable,
        default_args: Optional[
            Union[
                Dict[str, Dict[str, Type[FlatPageSitemap]]],
                Dict[str, Dict[str, Sitemap]],
                Dict[str, OrderedDict],
                Dict[str, str],
            ]
        ] = ...,
        name: Optional[str] = ...,
    ) -> None: ...
    def check(self) -> List[Warning]: ...
    def resolve(self, path: str) -> Optional[ResolverMatch]: ...
    def lookup_str(self) -> str: ...

class URLResolver:
    url_patterns: List[Tuple[str, Callable]]
    urlconf_module: Optional[Union[List[Tuple[str, Callable]], Type[Any]]]
    pattern: Union[
        django.urls.resolvers.CheckURLMixin,
        django.urls.resolvers.LocalePrefixPattern,
    ] = ...
    urlconf_name: Optional[
        Union[
            List[List[Any]],
            List[Tuple[str, Callable]],
            List[django.urls.resolvers.URLPattern],
            List[django.urls.resolvers.URLResolver],
            Type[Any],
            str,
        ]
    ] = ...
    callback: None = ...
    default_kwargs: Dict[str, Union[Dict[Any, Any], str]] = ...
    namespace: Optional[str] = ...
    app_name: Optional[str] = ...
    def __init__(
        self,
        pattern: Union[CheckURLMixin, LocalePrefixPattern],
        urlconf_name: Optional[
            Union[
                List[List[Any]],
                List[Tuple[str, Callable]],
                List[URLPattern],
                List[URLResolver],
                Type[Any],
                str,
            ]
        ],
        default_kwargs: Optional[
            Union[Dict[str, Dict[Any, Any]], Dict[str, str]]
        ] = ...,
        app_name: Optional[str] = ...,
        namespace: Optional[str] = ...,
    ) -> None: ...
    def check(self) -> List[CheckMessage]: ...
    @property
    def reverse_dict(self) -> MultiValueDict: ...
    @property
    def namespace_dict(self) -> Dict[str, Tuple[str, URLResolver]]: ...
    @property
    def app_dict(self) -> Dict[str, List[str]]: ...
    def resolve(self, path: str) -> ResolverMatch: ...
    def urlconf_module(
        self
    ) -> Optional[Union[List[Tuple[str, Callable]], Type[Any]]]: ...
    def url_patterns(self) -> List[Tuple[str, Callable]]: ...
    def resolve_error_handler(
        self, view_type: int
    ) -> Tuple[Callable, Dict[Any, Any]]: ...
    def reverse(self, lookup_view: str, *args: Any, **kwargs: Any) -> str: ...