SYMBOL INDEX (1358 symbols across 143 files)

FILE: .eslintrc.js
  constant OFF (line 1) | const OFF = 0;
  constant WARNING (line 2) | const WARNING = 1;
  constant ERROR (line 3) | const ERROR = 2;

FILE: nonebot/__init__.py
  function get_driver (line 71) | def get_driver() -> Driver:
  function get_adapter (line 94) | def get_adapter(name: str) -> Adapter:
  function get_adapter (line 105) | def get_adapter(name: type[A]) -> A:
  function get_adapter (line 115) | def get_adapter(name: str | type[Adapter]) -> Adapter:
  function get_adapters (line 136) | def get_adapters() -> dict[str, Adapter]:
  function get_app (line 154) | def get_app() -> Any:
  function get_asgi (line 175) | def get_asgi() -> Any:
  function get_bot (line 199) | def get_bot(self_id: str | None = None) -> Bot:
  function get_bots (line 235) | def get_bots() -> dict[str, Bot]:
  function _resolve_combine_expr (line 254) | def _resolve_combine_expr(obj_str: str) -> type[Driver]:
  function _log_patcher (line 270) | def _log_patcher(record: "loguru.Record"):
  function init (line 280) | def init(*, _env_file: DOTENV_TYPE | None = None, **kwargs: Any) -> None:
  function run (line 324) | def run(*args: Any, **kwargs: Any) -> None:

FILE: nonebot/compat.py
  class _CustomValidationClass (line 42) | class _CustomValidationClass(Protocol):
    method __get_validators__ (line 44) | def __get_validators__(cls) -> Generator[Callable[..., Any], None, Non...
  function _get_legacy_union_field (line 110) | def _get_legacy_union_field(func: Callable[P, T]) -> Callable[P, T]:
  class FieldInfo (line 121) | class FieldInfo(BaseFieldInfo):  # pyright: ignore[reportGeneralTypeIssues]
    method __init__ (line 125) | def __init__(self, default: Any = PydanticUndefined, **kwargs: Any) ->...
    method extra (line 129) | def extra(self) -> dict[str, Any]:
    method _inherit_construct (line 142) | def _inherit_construct(
    method __init__ (line 323) | def __init__(self, default: Any = PydanticUndefined, **kwargs: Any):
    method _inherit_construct (line 331) | def _inherit_construct(
  class ModelField (line 156) | class ModelField:
    method _construct (line 167) | def _construct(cls, name: str, annotation: Any, field_info: FieldInfo)...
    method construct (line 171) | def construct(
    method __hash__ (line 177) | def __hash__(self) -> int:
    method type_adapter (line 183) | def type_adapter(self) -> TypeAdapter:
    method _annotation_has_config (line 196) | def _annotation_has_config(self) -> bool:
    method get_default (line 215) | def get_default(self) -> Any:
    method _type_display (line 219) | def _type_display(self):
    method validate_value (line 223) | def validate_value(self, value: Any) -> Any:
    method _construct (line 348) | def _construct(cls, name: str, annotation: Any, field_info: FieldInfo)...
    method construct (line 364) | def construct(
    method validate_value (line 377) | def validate_value(self, value: Any) -> Any:
  function model_fields (line 227) | def model_fields(model: type[BaseModel]) -> list[ModelField]:
  function model_config (line 239) | def model_config(model: type[BaseModel]) -> Any:
  function model_dump (line 243) | def model_dump(
  function type_validate_python (line 262) | def type_validate_python(type_: type[T], data: Any) -> T:
  function type_validate_json (line 266) | def type_validate_json(type_: type[T], data: str | bytes) -> T:
  function __get_pydantic_core_schema__ (line 270) | def __get_pydantic_core_schema__(
  function custom_validation (line 282) | def custom_validation(class_: type["CVC"]) -> type["CVC"]:
  class ConfigDict (line 308) | class ConfigDict(PydanticConfig):
    method get (line 312) | def get(cls, field: str, default: Any = None) -> Any:
  class DEFAULT_CONFIG (line 316) | class DEFAULT_CONFIG(ConfigDict):
  class FieldInfo (line 322) | class FieldInfo(BaseFieldInfo):
    method __init__ (line 125) | def __init__(self, default: Any = PydanticUndefined, **kwargs: Any) ->...
    method extra (line 129) | def extra(self) -> dict[str, Any]:
    method _inherit_construct (line 142) | def _inherit_construct(
    method __init__ (line 323) | def __init__(self, default: Any = PydanticUndefined, **kwargs: Any):
    method _inherit_construct (line 331) | def _inherit_construct(
  class ModelField (line 346) | class ModelField(BaseModelField):
    method _construct (line 167) | def _construct(cls, name: str, annotation: Any, field_info: FieldInfo)...
    method construct (line 171) | def construct(
    method __hash__ (line 177) | def __hash__(self) -> int:
    method type_adapter (line 183) | def type_adapter(self) -> TypeAdapter:
    method _annotation_has_config (line 196) | def _annotation_has_config(self) -> bool:
    method get_default (line 215) | def get_default(self) -> Any:
    method _type_display (line 219) | def _type_display(self):
    method validate_value (line 223) | def validate_value(self, value: Any) -> Any:
    method _construct (line 348) | def _construct(cls, name: str, annotation: Any, field_info: FieldInfo)...
    method construct (line 364) | def construct(
    method validate_value (line 377) | def validate_value(self, value: Any) -> Any:
  class TypeAdapter (line 384) | class TypeAdapter(Generic[T]):
    method __init__ (line 386) | def __init__(
    method __init__ (line 394) | def __init__(
    method __init__ (line 401) | def __init__(
    method validate_python (line 410) | def validate_python(self, value: Any) -> T:
    method validate_json (line 413) | def validate_json(self, value: str | bytes) -> T:
  function field_validator (line 417) | def field_validator(
  function field_validator (line 426) | def field_validator(
  function field_validator (line 434) | def field_validator(
  function model_fields (line 454) | def model_fields(model: type[BaseModel]) -> list[ModelField]:
  function model_config (line 467) | def model_config(model: type[BaseModel]) -> Any:
  function model_dump (line 471) | def model_dump(
  function model_validator (line 490) | def model_validator(*, mode: Literal["before"]): ...
  function model_validator (line 493) | def model_validator(*, mode: Literal["after"]): ...
  function model_validator (line 495) | def model_validator(*, mode: Literal["before", "after"]):
  function type_validate_python (line 501) | def type_validate_python(type_: type[T], data: Any) -> T:
  function type_validate_json (line 505) | def type_validate_json(type_: type[T], data: str | bytes) -> T:
  function custom_validation (line 509) | def custom_validation(class_: type["CVC"]) -> type["CVC"]:

FILE: nonebot/config.py
  class SettingsError (line 48) | class SettingsError(ValueError): ...
  class BaseSettingsSource (line 51) | class BaseSettingsSource(abc.ABC):
    method __init__ (line 52) | def __init__(self, settings_cls: type[BaseModel]) -> None:
    method config (line 56) | def config(self) -> "SettingsConfig":
    method __call__ (line 60) | def __call__(self) -> dict[str, Any]:
  class InitSettingsSource (line 64) | class InitSettingsSource(BaseSettingsSource):
    method __init__ (line 67) | def __init__(
    method __call__ (line 73) | def __call__(self) -> dict[str, Any]:
    method __repr__ (line 76) | def __repr__(self) -> str:
  class DotEnvSettingsSource (line 80) | class DotEnvSettingsSource(BaseSettingsSource):
    method __init__ (line 81) | def __init__(
    method _apply_case_sensitive (line 95) | def _apply_case_sensitive(self, var_name: str) -> str:
    method _field_is_complex (line 98) | def _field_is_complex(self, field: ModelField) -> tuple[bool, bool]:
    method _parse_env_vars (line 107) | def _parse_env_vars(
    method _read_env_file (line 114) | def _read_env_file(self, file_path: Path) -> dict[str, str | None]:
    method _read_env_files (line 118) | def _read_env_files(self) -> dict[str, str | None]:
    method _next_field (line 133) | def _next_field(self, field: ModelField | None, key: str) -> ModelFiel...
    method _explode_env_vars (line 142) | def _explode_env_vars(
    method __call__ (line 183) | def __call__(self) -> dict[str, Any]:
  class SettingsConfig (line 290) | class SettingsConfig(ConfigDict, total=False):
  class SettingsConfig (line 298) | class SettingsConfig(ConfigDict):
  class BaseSettings (line 305) | class BaseSettings(BaseModel):
    method __getattr__ (line 308) | def __getattr__(self, name: str) -> Any:  # pragma: no cover
    class Config (line 321) | class Config(SettingsConfig):
    method __init__ (line 328) | def __init__(
    method _settings_build_values (line 367) | def _settings_build_values(
  class Env (line 384) | class Env(BaseSettings):
  class Config (line 397) | class Config(BaseSettings):
    class Config (line 495) | class Config(  # pyright: ignore[reportIncompatibleVariableOverride]

FILE: nonebot/dependencies/__init__.py
  class Param (line 37) | class Param(abc.ABC, FieldInfo):
    method __init__ (line 43) | def __init__(self, *args, validate: bool = False, **kwargs: Any) -> None:
    method _check_param (line 48) | def _check_param(
    method _check_parameterless (line 54) | def _check_parameterless(
    method _solve (line 60) | async def _solve(self, **kwargs: Any) -> Any:
    method _check (line 63) | async def _check(self, **kwargs: Any) -> None:
  class Dependent (line 68) | class Dependent(Generic[R]):
    method __repr__ (line 83) | def __repr__(self) -> str:
    method __call__ (line 94) | async def __call__(self, **kwargs: Any) -> R:
    method parse_params (line 120) | def parse_params(
    method parse_parameterless (line 152) | def parse_parameterless(
    method parse (line 166) | def parse(
    method check (line 184) | async def check(self, **params: Any) -> None:
    method _solve_field (line 197) | async def _solve_field(self, field: ModelField, params: dict[str, Any]...
    method solve (line 205) | async def solve(self, **params: Any) -> dict[str, Any]:

FILE: nonebot/dependencies/utils.py
  function get_typed_signature (line 21) | def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature:
  function get_typed_annotation (line 38) | def get_typed_annotation(param: inspect.Parameter, globalns: dict[str, A...
  function check_field_type (line 57) | def check_field_type(field: ModelField, value: Any) -> Any:

FILE: nonebot/drivers/aiohttp.py
  class Session (line 58) | class Session(HTTPClientSession):
    method __init__ (line 60) | def __init__(
    method client (line 100) | def client(self) -> aiohttp.ClientSession:
    method request (line 106) | async def request(self, setup: Request) -> Response:
    method stream_request (line 151) | async def stream_request(
    method setup (line 203) | async def setup(self) -> None:
    method close (line 216) | async def close(self) -> None:
  class Mixin (line 224) | class Mixin(HTTPClientMixin, WebSocketClientMixin):
    method type (line 229) | def type(self) -> str:
    method request (line 233) | async def request(self, setup: Request) -> Response:
    method stream_request (line 238) | async def stream_request(
    method websocket (line 250) | async def websocket(self, setup: Request) -> AsyncGenerator["WebSocket...
    method get_session (line 277) | def get_session(
  class WebSocket (line 296) | class WebSocket(BaseWebSocket):
    method __init__ (line 299) | def __init__(
    method closed (line 312) | def closed(self):
    method accept (line 316) | async def accept(self):
    method close (line 320) | async def close(self, code: int = 1000, reason: str = ""):
    method _receive (line 324) | async def _receive(self) -> aiohttp.WSMessage:
    method receive (line 335) | async def receive(self) -> str:
    method receive_text (line 344) | async def receive_text(self) -> str:
    method receive_bytes (line 353) | async def receive_bytes(self) -> bytes:
    method send_text (line 362) | async def send_text(self, data: str) -> None:
    method send_bytes (line 366) | async def send_bytes(self, data: bytes) -> None:
  class Driver (line 372) | class Driver(Mixin, NoneDriver): ...

FILE: nonebot/drivers/fastapi.py
  function catch_closed (line 50) | def catch_closed(func):
  class Config (line 63) | class Config(BaseModel):
  class Driver (line 88) | class Driver(BaseDriver, ASGIMixin):
    method __init__ (line 91) | def __init__(self, env: Env, config: NoneBotConfig):
    method type (line 106) | def type(self) -> str:
    method server_app (line 112) | def server_app(self) -> FastAPI:
    method asgi (line 118) | def asgi(self) -> FastAPI:
    method logger (line 124) | def logger(self) -> logging.Logger:
    method setup_http_server (line 129) | def setup_http_server(self, setup: HTTPServerSetup):
    method setup_websocket_server (line 142) | def setup_websocket_server(self, setup: WebSocketServerSetup) -> None:
    method _lifespan_manager (line 153) | async def _lifespan_manager(self, app: FastAPI):
    method run (line 161) | def run(
    method _handle_http (line 200) | async def _handle_http(
    method _handle_ws (line 240) | async def _handle_ws(self, websocket: WebSocket, setup: WebSocketServe...
  class FastAPIWebSocket (line 256) | class FastAPIWebSocket(BaseWebSocket):
    method __init__ (line 260) | def __init__(self, *, request: BaseRequest, websocket: WebSocket):
    method closed (line 266) | def closed(self) -> bool:
    method accept (line 273) | async def accept(self) -> None:
    method close (line 277) | async def close(
    method receive (line 283) | async def receive(self) -> str | bytes:
    method receive_text (line 292) | async def receive_text(self) -> str:
    method receive_bytes (line 297) | async def receive_bytes(self) -> bytes:
    method send_text (line 301) | async def send_text(self, data: str) -> None:
    method send_bytes (line 305) | async def send_bytes(self, data: bytes) -> None:

FILE: nonebot/drivers/httpx.py
  class Session (line 54) | class Session(HTTPClientSession):
    method __init__ (line 56) | def __init__(
    method client (line 88) | def client(self) -> httpx.AsyncClient:
    method request (line 94) | async def request(self, setup: Request) -> Response:
    method stream_request (line 125) | async def stream_request(
    method setup (line 163) | async def setup(self) -> None:
    method close (line 177) | async def close(self) -> None:
  class Mixin (line 185) | class Mixin(HTTPClientMixin):
    method type (line 190) | def type(self) -> str:
    method request (line 194) | async def request(self, setup: Request) -> Response:
    method stream_request (line 201) | async def stream_request(
    method get_session (line 214) | def get_session(
  class Driver (line 235) | class Driver(Mixin, NoneDriver): ...

FILE: nonebot/drivers/none.py
  class Driver (line 35) | class Driver(BaseDriver):
    method __init__ (line 38) | def __init__(self, env: Env, config: Config):
    method type (line 46) | def type(self) -> str:
    method logger (line 52) | def logger(self):
    method run (line 57) | def run(self, *args, **kwargs):
    method _serve (line 62) | async def _serve(self):
    method _handle_signals (line 68) | async def _handle_signals(self):
    method _handle_legacy_signal (line 79) | def _handle_legacy_signal(self, sig, frame):
    method _handle_lifespan (line 82) | async def _handle_lifespan(self, tg: TaskGroup):
    method _startup (line 95) | async def _startup(self):
    method _listen_exit (line 114) | async def _listen_exit(self, tg: TaskGroup | None = None):
    method _shutdown (line 120) | async def _shutdown(self):
    method _listen_force_exit (line 146) | async def _listen_force_exit(self, tg: TaskGroup):
    method exit (line 150) | def exit(self, force: bool = False):

FILE: nonebot/drivers/quart.py
  function catch_closed (line 52) | def catch_closed(func):
  class Config (line 63) | class Config(BaseModel):
  class Driver (line 80) | class Driver(BaseDriver, ASGIMixin):
    method __init__ (line 83) | def __init__(self, env: Env, config: NoneBotConfig):
    method type (line 96) | def type(self) -> str:
    method server_app (line 102) | def server_app(self) -> Quart:
    method asgi (line 108) | def asgi(self):
    method logger (line 114) | def logger(self):
    method setup_http_server (line 119) | def setup_http_server(self, setup: HTTPServerSetup):
    method setup_websocket_server (line 131) | def setup_websocket_server(self, setup: WebSocketServerSetup) -> None:
    method run (line 142) | def run(
    method _handle_http (line 181) | async def _handle_http(self, setup: HTTPServerSetup) -> Response:
    method _handle_ws (line 216) | async def _handle_ws(self, setup: WebSocketServerSetup) -> None:
  class WebSocket (line 233) | class WebSocket(BaseWebSocket):
    method __init__ (line 236) | def __init__(self, *, request: BaseRequest, websocket_ctx: WebsocketCo...
    method websocket (line 241) | def websocket(self) -> QuartWebSocket:
    method closed (line 246) | def closed(self):
    method accept (line 251) | async def accept(self):
    method close (line 255) | async def close(self, code: int = 1000, reason: str = ""):
    method receive (line 260) | async def receive(self) -> str | bytes:
    method receive_text (line 265) | async def receive_text(self) -> str:
    method receive_bytes (line 273) | async def receive_bytes(self) -> bytes:
    method send_text (line 280) | async def send_text(self, data: str):
    method send_bytes (line 284) | async def send_bytes(self, data: bytes):

FILE: nonebot/drivers/websockets.py
  function catch_closed (line 49) | def catch_closed(
  class Mixin (line 62) | class Mixin(WebSocketClientMixin):
    method type (line 67) | def type(self) -> str:
    method websocket (line 72) | async def websocket(self, setup: Request) -> AsyncGenerator["WebSocket...
  class WebSocket (line 88) | class WebSocket(BaseWebSocket):
    method __init__ (line 92) | def __init__(self, *, request: Request, websocket: ClientConnection):
    method closed (line 98) | def closed(self) -> bool:
    method accept (line 102) | async def accept(self):
    method close (line 106) | async def close(self, code: int = 1000, reason: str = ""):
    method receive (line 111) | async def receive(self) -> str | bytes:
    method receive_text (line 116) | async def receive_text(self) -> str:
    method receive_bytes (line 124) | async def receive_bytes(self) -> bytes:
    method send_text (line 131) | async def send_text(self, data: str) -> None:
    method send_bytes (line 135) | async def send_bytes(self, data: bytes) -> None:
  class Driver (line 141) | class Driver(Mixin, NoneDriver): ...

FILE: nonebot/exception.py
  class NoneBotException (line 39) | class NoneBotException(Exception):
    method __str__ (line 42) | def __str__(self) -> str:
  class ParserExit (line 47) | class ParserExit(NoneBotException):
    method __init__ (line 50) | def __init__(self, status: int = 0, message: str | None = None) -> None:
    method __repr__ (line 54) | def __repr__(self) -> str:
  class ProcessException (line 63) | class ProcessException(NoneBotException):
  class IgnoredException (line 67) | class IgnoredException(ProcessException):
    method __init__ (line 74) | def __init__(self, reason: Any) -> None:
    method __repr__ (line 77) | def __repr__(self) -> str:
  class SkippedException (line 81) | class SkippedException(ProcessException):
  class TypeMisMatch (line 98) | class TypeMisMatch(SkippedException):
    method __init__ (line 101) | def __init__(self, param: ModelField, value: Any) -> None:
    method __repr__ (line 105) | def __repr__(self) -> str:
  class MockApiException (line 112) | class MockApiException(ProcessException):
    method __init__ (line 120) | def __init__(self, result: Any):
    method __repr__ (line 123) | def __repr__(self) -> str:
  class StopPropagation (line 127) | class StopPropagation(ProcessException):
  class MatcherException (line 145) | class MatcherException(NoneBotException):
  class PausedException (line 149) | class PausedException(MatcherException):
  class RejectedException (line 164) | class RejectedException(MatcherException):
  class FinishedException (line 179) | class FinishedException(MatcherException):
  class AdapterException (line 194) | class AdapterException(NoneBotException):
    method __init__ (line 201) | def __init__(self, adapter_name: str, *args: object) -> None:
  class NoLogException (line 206) | class NoLogException(AdapterException):
  class ApiNotAvailable (line 213) | class ApiNotAvailable(AdapterException):
  class NetworkError (line 217) | class NetworkError(AdapterException):
  class ActionFailed (line 223) | class ActionFailed(AdapterException):
  class DriverException (line 228) | class DriverException(NoneBotException):
  class WebSocketClosed (line 232) | class WebSocketClosed(DriverException):
    method __init__ (line 235) | def __init__(self, code: int, reason: str | None = None) -> None:
    method __repr__ (line 239) | def __repr__(self) -> str:

FILE: nonebot/internal/adapter/adapter.py
  class Adapter (line 23) | class Adapter(abc.ABC):
    method __init__ (line 33) | def __init__(self, driver: Driver, **kwargs: Any):
    method __repr__ (line 39) | def __repr__(self) -> str:
    method get_name (line 44) | def get_name(cls) -> str:
    method config (line 49) | def config(self) -> Config:
    method bot_connect (line 53) | def bot_connect(self, bot: Bot) -> None:
    method bot_disconnect (line 64) | def bot_disconnect(self, bot: Bot) -> None:
    method setup_http_server (line 76) | def setup_http_server(self, setup: HTTPServerSetup):
    method setup_websocket_server (line 82) | def setup_websocket_server(self, setup: WebSocketServerSetup):
    method request (line 88) | async def request(self, setup: Request) -> Response:
    method websocket (line 95) | async def websocket(self, setup: Request) -> AsyncGenerator[WebSocket,...
    method on_ready (line 102) | def on_ready(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
    method _call_api (line 106) | async def _call_api(self, bot: Bot, api: str, **data: Any) -> Any:

FILE: nonebot/internal/adapter/bot.py
  class _ApiCall (line 19) | class _ApiCall(Protocol):
    method __call__ (line 20) | async def __call__(self, **kwargs: Any) -> Any: ...
  class Bot (line 23) | class Bot(abc.ABC):
    method __init__ (line 38) | def __init__(self, adapter: "Adapter", self_id: str):
    method __repr__ (line 44) | def __repr__(self) -> str:
    method __getattr__ (line 47) | def __getattr__(self, name: str) -> "_ApiCall":
    method type (line 55) | def type(self) -> str:
    method config (line 60) | def config(self) -> Config:
    method call_api (line 64) | async def call_api(self, api: str, **data: Any) -> Any:
    method send (line 180) | async def send(
    method on_calling_api (line 196) | def on_calling_api(cls, func: T_CallingAPIHook) -> T_CallingAPIHook:
    method on_called_api (line 209) | def on_called_api(cls, func: T_CalledAPIHook) -> T_CalledAPIHook:

FILE: nonebot/internal/adapter/event.py
  class Event (line 14) | class Event(abc.ABC, BaseModel):
    class Config (line 21) | class Config(ConfigDict):
    method validate (line 28) | def validate(cls: type["E"], value: Any) -> "E":
    method get_type (line 34) | def get_type(self) -> str:
    method get_event_name (line 39) | def get_event_name(self) -> str:
    method get_event_description (line 44) | def get_event_description(self) -> str:
    method __str__ (line 48) | def __str__(self) -> str:
    method get_log_string (line 51) | def get_log_string(self) -> str:
    method get_user_id (line 63) | def get_user_id(self) -> str:
    method get_session_id (line 68) | def get_session_id(self) -> str:
    method get_message (line 75) | def get_message(self) -> "Message":
    method get_plaintext (line 79) | def get_plaintext(self) -> str:
    method is_tome (line 87) | def is_tome(self) -> bool:

FILE: nonebot/internal/adapter/message.py
  class MessageSegment (line 25) | class MessageSegment(abc.ABC, Generic[TM]):
    method get_message_class (line 35) | def get_message_class(cls) -> Type[TM]:  # noqa: UP006
    method __str__ (line 40) | def __str__(self) -> str:
    method __len__ (line 44) | def __len__(self) -> int:
    method __ne__ (line 47) | def __ne__(  # pyright: ignore[reportIncompatibleMethodOverride]
    method __add__ (line 52) | def __add__(self, other: str | Self | Iterable[Self]) -> TM:
    method __radd__ (line 55) | def __radd__(self, other: str | Self | Iterable[Self]) -> TM:
    method __get_validators__ (line 59) | def __get_validators__(cls):
    method _validate (line 63) | def _validate(cls, value) -> Self:
    method get (line 76) | def get(self, key: str, default: Any = None):
    method keys (line 79) | def keys(self):
    method values (line 82) | def values(self):
    method items (line 85) | def items(self):
    method join (line 88) | def join(self, iterable: Iterable[Self | TM]) -> TM:
    method copy (line 91) | def copy(self) -> Self:
    method is_text (line 95) | def is_text(self) -> bool:
  class Message (line 101) | class Message(list[TMS], abc.ABC):
    method __init__ (line 108) | def __init__(
    method template (line 125) | def template(cls, format_string: str | TM) -> MessageTemplate[Self]:
    method get_segment_class (line 142) | def get_segment_class(cls) -> type[TMS]:
    method __str__ (line 146) | def __str__(self) -> str:
    method __get_validators__ (line 150) | def __get_validators__(cls):
    method _validate (line 154) | def _validate(cls, value) -> Self:
    method _construct (line 173) | def _construct(msg: str) -> Iterable[TMS]:
    method __add__ (line 177) | def __add__(  # pyright: ignore[reportIncompatibleMethodOverride]
    method __radd__ (line 184) | def __radd__(self, other: str | TMS | Iterable[TMS]) -> Self:
    method __iadd__ (line 188) | def __iadd__(self, other: str | TMS | Iterable[TMS]) -> Self:
    method __getitem__ (line 200) | def __getitem__(self, args: str) -> Self:
    method __getitem__ (line 211) | def __getitem__(self, args: tuple[str, int]) -> TMS:
    method __getitem__ (line 222) | def __getitem__(self, args: tuple[str, slice]) -> Self:
    method __getitem__ (line 233) | def __getitem__(self, args: int) -> TMS:
    method __getitem__ (line 244) | def __getitem__(self, args: slice) -> Self:
    method __getitem__ (line 254) | def __getitem__(  # pyright: ignore[reportIncompatibleMethodOverride]
    method __contains__ (line 272) | def __contains__(  # pyright: ignore[reportIncompatibleMethodOverride]
    method has (line 286) | def has(self, value: TMS | str) -> bool:
    method index (line 290) | def index(self, value: TMS | str, *args: SupportsIndex) -> int:
    method get (line 310) | def get(self, type_: str, count: int | None = None) -> Self:
    method count (line 334) | def count(self, value: TMS | str) -> int:
    method only (line 345) | def only(self, value: TMS | str) -> bool:
    method append (line 358) | def append(  # pyright: ignore[reportIncompatibleMethodOverride]
    method extend (line 374) | def extend(  # pyright: ignore[reportIncompatibleMethodOverride]
    method join (line 386) | def join(self, iterable: Iterable[TMS | Self]) -> Self:
    method copy (line 405) | def copy(self) -> Self:
    method include (line 409) | def include(self, *types: str) -> Self:
    method exclude (line 420) | def exclude(self, *types: str) -> Self:
    method extract_plain_text (line 431) | def extract_plain_text(self) -> str:

FILE: nonebot/internal/adapter/template.py
  function formatter_field_name_split (line 18) | def formatter_field_name_split(
  class MessageTemplate (line 30) | class MessageTemplate(Formatter, Generic[TF]):
    method __init__ (line 40) | def __init__(
    method __init__ (line 48) | def __init__(
    method __init__ (line 55) | def __init__(
    method __repr__ (line 66) | def __repr__(self) -> str:
    method add_format_spec (line 69) | def add_format_spec(
    method format (line 78) | def format(  # pyright: ignore[reportIncompatibleMethodOverride]
    method format_map (line 84) | def format_map(self, mapping: Mapping[str, Any]) -> TF:
    method _format (line 88) | def _format(self, args: Sequence[Any], kwargs: Mapping[str, Any]) -> TF:
    method vformat (line 113) | def vformat(  # pyright: ignore[reportIncompatibleMethodOverride]
    method _vformat (line 121) | def _vformat(  # pyright: ignore[reportIncompatibleMethodOverride]
    method get_field (line 178) | def get_field(
    method format_field (line 191) | def format_field(self, value: Any, format_spec: str) -> Any:
    method _add (line 204) | def _add(self, a: Any, b: Any) -> Any:

FILE: nonebot/internal/driver/_lifespan.py
  class Lifespan (line 16) | class Lifespan:
    method __init__ (line 17) | def __init__(self) -> None:
    method task_group (line 25) | def task_group(self) -> TaskGroup:
    method task_group (line 31) | def task_group(self, task_group: TaskGroup) -> None:
    method on_startup (line 36) | def on_startup(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
    method on_shutdown (line 40) | def on_shutdown(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
    method on_ready (line 44) | def on_ready(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
    method _run_lifespan_func (line 49) | async def _run_lifespan_func(
    method startup (line 58) | async def startup(self) -> None:
    method shutdown (line 71) | async def shutdown(
    method __aenter__ (line 90) | async def __aenter__(self) -> None:
    method __aexit__ (line 93) | async def __aexit__(

FILE: nonebot/internal/driver/abstract.py
  class Driver (line 45) | class Driver(abc.ABC):
    method __init__ (line 62) | def __init__(self, env: Env, config: Config):
    method __repr__ (line 70) | def __repr__(self) -> str:
    method bots (line 77) | def bots(self) -> dict[str, "Bot"]:
    method task_group (line 82) | def task_group(self) -> TaskGroup:
    method register_adapter (line 85) | def register_adapter(self, adapter: type["Adapter"], **kwargs) -> None:
    method type (line 105) | def type(self) -> str:
    method logger (line 111) | def logger(self):
    method run (line 116) | def run(self, *args, **kwargs):
    method on_startup (line 122) | def on_startup(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
    method on_shutdown (line 126) | def on_shutdown(self, func: LIFESPAN_FUNC) -> LIFESPAN_FUNC:
    method on_bot_connect (line 131) | def on_bot_connect(cls, func: T_BotConnectionHook) -> T_BotConnectionH...
    method on_bot_disconnect (line 144) | def on_bot_disconnect(cls, func: T_BotDisconnectionHook) -> T_BotDisco...
    method _bot_connect (line 156) | def _bot_connect(self, bot: "Bot") -> None:
    method _bot_disconnect (line 188) | def _bot_disconnect(self, bot: "Bot") -> None:
  class Mixin (line 221) | class Mixin(abc.ABC):
    method type (line 226) | def type(self) -> str:
  class ForwardMixin (line 231) | class ForwardMixin(Mixin):
  class ReverseMixin (line 235) | class ReverseMixin(Mixin):
  class HTTPClientSession (line 239) | class HTTPClientSession(abc.ABC):
    method __init__ (line 243) | def __init__(
    method request (line 255) | async def request(self, setup: Request) -> Response:
    method stream_request (line 260) | async def stream_request(
    method setup (line 271) | async def setup(self) -> None:
    method close (line 276) | async def close(self) -> None:
    method __aenter__ (line 280) | async def __aenter__(self) -> Self:
    method __aexit__ (line 284) | async def __aexit__(
  class HTTPClientMixin (line 293) | class HTTPClientMixin(ForwardMixin):
    method request (line 297) | async def request(self, setup: Request) -> Response:
    method stream_request (line 302) | async def stream_request(
    method get_session (line 313) | def get_session(
  class WebSocketClientMixin (line 326) | class WebSocketClientMixin(ForwardMixin):
    method websocket (line 331) | async def websocket(self, setup: Request) -> AsyncGenerator[WebSocket,...
  class ASGIMixin (line 337) | class ASGIMixin(ReverseMixin):
    method server_app (line 345) | def server_app(self) -> Any:
    method asgi (line 351) | def asgi(self) -> Any:
    method setup_http_server (line 356) | def setup_http_server(self, setup: "HTTPServerSetup") -> None:
    method setup_websocket_server (line 361) | def setup_websocket_server(self, setup: "WebSocketServerSetup") -> None:

FILE: nonebot/internal/driver/combine.py
  class CombinedDriver (line 9) | class CombinedDriver(Driver, Mixin): ...
  function combine_driver (line 13) | def combine_driver(driver: type[D]) -> type[D]: ...
  function combine_driver (line 17) | def combine_driver(
  function combine_driver (line 22) | def combine_driver(

FILE: nonebot/internal/driver/model.py
  class Timeout (line 14) | class Timeout:
  class HTTPVersion (line 51) | class HTTPVersion(Enum):
  class Request (line 57) | class Request:
    method __init__ (line 58) | def __init__(
    method __repr__ (line 126) | def __repr__(self) -> str:
  class Response (line 130) | class Response:
    method __init__ (line 131) | def __init__(
    method __repr__ (line 152) | def __repr__(self) -> str:
  class WebSocket (line 156) | class WebSocket(abc.ABC):
    method __init__ (line 157) | def __init__(self, *, request: Request):
    method __repr__ (line 160) | def __repr__(self) -> str:
    method closed (line 165) | def closed(self) -> bool:
    method accept (line 170) | async def accept(self) -> None:
    method close (line 175) | async def close(self, code: int = 1000, reason: str = "") -> None:
    method receive (line 180) | async def receive(self) -> str | bytes:
    method receive_text (line 185) | async def receive_text(self) -> str:
    method receive_bytes (line 190) | async def receive_bytes(self) -> bytes:
    method send (line 194) | async def send(self, data: str | bytes) -> None:
    method send_text (line 204) | async def send_text(self, data: str) -> None:
    method send_bytes (line 209) | async def send_bytes(self, data: bytes) -> None:
  class Cookies (line 214) | class Cookies(MutableMapping):
    method __init__ (line 215) | def __init__(self, cookies: CookieTypes = None) -> None:
    method set (line 230) | def set(self, name: str, value: str, domain: str = "", path: str = "/"...
    method get (line 252) | def get(  # pyright: ignore[reportIncompatibleMethodOverride]
    method delete (line 273) | def delete(
    method clear (line 290) | def clear(self, domain: str | None = None, path: str | None = None) ->...
    method update (line 293) | def update(  # pyright: ignore[reportIncompatibleMethodOverride]
    method as_header (line 300) | def as_header(self, request: Request) -> dict[str, str]:
    method __setitem__ (line 305) | def __setitem__(self, name: str, value: str) -> None:
    method __getitem__ (line 308) | def __getitem__(self, name: str) -> str:
    method __delitem__ (line 314) | def __delitem__(self, name: str) -> None:
    method __len__ (line 317) | def __len__(self) -> int:
    method __iter__ (line 320) | def __iter__(self) -> Iterator[Cookie]:
    method __repr__ (line 323) | def __repr__(self) -> str:
    class _CookieCompatRequest (line 330) | class _CookieCompatRequest(urllib.request.Request):
      method __init__ (line 331) | def __init__(self, request: Request) -> None:
      method add_unredirected_header (line 340) | def add_unredirected_header(  # pyright: ignore[reportIncompatibleMe...
  class HTTPServerSetup (line 348) | class HTTPServerSetup:
  class WebSocketServerSetup (line 358) | class WebSocketServerSetup:

FILE: nonebot/internal/matcher/manager.py
  class MatcherManager (line 12) | class MatcherManager(MutableMapping[int, list[type["Matcher"]]]):
    method __init__ (line 18) | def __init__(self):
    method __repr__ (line 21) | def __repr__(self) -> str:
    method __contains__ (line 24) | def __contains__(self, o: object) -> bool:
    method __iter__ (line 27) | def __iter__(self) -> Iterator[int]:
    method __len__ (line 30) | def __len__(self) -> int:
    method __getitem__ (line 33) | def __getitem__(self, key: int) -> list[type["Matcher"]]:
    method __setitem__ (line 36) | def __setitem__(self, key: int, value: list[type["Matcher"]]) -> None:
    method __delitem__ (line 39) | def __delitem__(self, key: int) -> None:
    method __eq__ (line 42) | def __eq__(self, other: object) -> bool:
    method keys (line 45) | def keys(self) -> KeysView[int]:
    method values (line 48) | def values(self) -> ValuesView[list[type["Matcher"]]]:
    method items (line 51) | def items(self) -> ItemsView[int, list[type["Matcher"]]]:
    method get (line 55) | def get(self, key: int) -> list[type["Matcher"]] | None: ...
    method get (line 58) | def get(
    method get (line 63) | def get(self, key: int, default: T) -> list[type["Matcher"]] | T: ...
    method get (line 65) | def get(
    method pop (line 70) | def pop(  # pyright: ignore[reportIncompatibleMethodOverride]
    method popitem (line 75) | def popitem(self) -> tuple[int, list[type["Matcher"]]]:
    method clear (line 78) | def clear(self) -> None:
    method update (line 81) | def update(  # pyright: ignore[reportIncompatibleMethodOverride]
    method setdefault (line 86) | def setdefault(
    method set_provider (line 91) | def set_provider(self, provider_class: type[MatcherProvider]) -> None:

FILE: nonebot/internal/matcher/matcher.py
  class MatcherSource (line 85) | class MatcherSource:
    method plugin (line 96) | def plugin(self) -> "Plugin | None":
    method plugin_name (line 104) | def plugin_name(self) -> str | None:
    method module (line 109) | def module(self) -> ModuleType | None:
    method file (line 114) | def file(self) -> Path | None:
  class MatcherMeta (line 119) | class MatcherMeta(type):
    method __repr__ (line 125) | def __repr__(self) -> str:
  class Matcher (line 138) | class Matcher(metaclass=MatcherMeta):
    method __init__ (line 178) | def __init__(self):
    method __repr__ (line 182) | def __repr__(self) -> str:
    method new (line 195) | def new(
    method destroy (line 328) | def destroy(cls) -> None:
    method plugin (line 333) | def plugin(cls) -> "Plugin | None":
    method plugin_id (line 338) | def plugin_id(cls) -> str | None:
    method plugin_name (line 343) | def plugin_name(cls) -> str | None:
    method module (line 348) | def module(cls) -> ModuleType | None:
    method module_name (line 353) | def module_name(cls) -> str | None:
    method check_perm (line 358) | async def check_perm(
    method check_rule (line 382) | async def check_rule(
    method type_updater (line 408) | def type_updater(cls, func: T_TypeUpdater) -> T_TypeUpdater:
    method permission_updater (line 420) | def permission_updater(cls, func: T_PermissionUpdater) -> T_Permission...
    method append_handler (line 432) | def append_handler(
    method handle (line 444) | def handle(
    method receive (line 460) | def receive(
    method got (line 501) | def got(
    method send (line 549) | async def send(
    method finish (line 571) | async def finish(
    method pause (line 588) | async def pause(
    method reject (line 612) | async def reject(
    method reject_arg (line 641) | async def reject_arg(
    method reject_receive (line 666) | async def reject_receive(
    method skip (line 691) | def skip(cls) -> NoReturn:
    method get_receive (line 699) | def get_receive(self, id: str) -> Event | None: ...
    method get_receive (line 702) | def get_receive(self, id: str, default: T) -> Event | T: ...
    method get_receive (line 704) | def get_receive(self, id: str, default: T | None = None) -> Event | T ...
    method set_receive (line 711) | def set_receive(self, id: str, event: Event) -> None:
    method get_last_receive (line 717) | def get_last_receive(self) -> Event | None: ...
    method get_last_receive (line 720) | def get_last_receive(self, default: T) -> Event | T: ...
    method get_last_receive (line 722) | def get_last_receive(self, default: T | None = None) -> Event | T | None:
    method get_arg (line 730) | def get_arg(self, key: str) -> Message | None: ...
    method get_arg (line 733) | def get_arg(self, key: str, default: T) -> Message | T: ...
    method get_arg (line 735) | def get_arg(self, key: str, default: T | None = None) -> Message | T |...
    method set_arg (line 742) | def set_arg(self, key: str, message: Message) -> None:
    method set_target (line 746) | def set_target(self, target: str, cache: bool = True) -> None:
    method get_target (line 753) | def get_target(self) -> str | None: ...
    method get_target (line 756) | def get_target(self, default: T) -> str | T: ...
    method get_target (line 758) | def get_target(self, default: T | None = None) -> str | T | None:
    method stop_propagation (line 761) | def stop_propagation(self):
    method update_type (line 765) | async def update_type(
    method update_permission (line 786) | async def update_permission(
    method resolve_reject (line 804) | async def resolve_reject(self):
    method ensure_context (line 811) | def ensure_context(self, bot: Bot, event: Event):
    method simple_run (line 822) | async def simple_run(
    method run (line 867) | async def run(

FILE: nonebot/internal/matcher/provider.py
  class MatcherProvider (line 10) | class MatcherProvider(abc.ABC, MutableMapping[int, list[type["Matcher"]]]):
    method __init__ (line 18) | def __init__(self, matchers: Mapping[int, list[type["Matcher"]]]):
  class _DictProvider (line 22) | class _DictProvider(defaultdict[int, list[type["Matcher"]]], MatcherProv...
    method __init__ (line 23) | def __init__(self, matchers: Mapping[int, list[type["Matcher"]]]):

FILE: nonebot/internal/params.py
  class DependsInner (line 47) | class DependsInner:
    method __init__ (line 48) | def __init__(
    method __repr__ (line 59) | def __repr__(self) -> str:
  function Depends (line 66) | def Depends(
  class CacheState (line 100) | class CacheState(str, Enum):
  class DependencyCache (line 107) | class DependencyCache:
    method __init__ (line 113) | def __init__(self):
    method done (line 119) | def done(self) -> bool:
    method result (line 122) | def result(self) -> Any:
    method exception (line 132) | def exception(self) -> BaseException | None:
    method set_result (line 140) | def set_result(self, result: Any) -> None:
    method set_exception (line 150) | def set_exception(self, exception: BaseException) -> None:
    method wait (line 160) | async def wait(self):
  class DependParam (line 172) | class DependParam(Param):
    method __init__ (line 180) | def __init__(
    method __repr__ (line 187) | def __repr__(self) -> str:
    method _from_field (line 191) | def _from_field(
    method _check_param (line 206) | def _check_param(
    method _check_parameterless (line 246) | def _check_parameterless(
    method _solve (line 257) | async def _solve(
    method _check (line 322) | async def _check(self, **kwargs: Any) -> None:
  class BotParam (line 327) | class BotParam(Param):
    method __init__ (line 335) | def __init__(self, *args, checker: ModelField | None = None, **kwargs:...
    method __repr__ (line 339) | def __repr__(self) -> str:
    method _check_param (line 348) | def _check_param(
    method _solve (line 366) | async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
    method _check (line 372) | async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
  class EventParam (line 379) | class EventParam(Param):
    method __init__ (line 387) | def __init__(self, *args, checker: ModelField | None = None, **kwargs:...
    method __repr__ (line 391) | def __repr__(self) -> str:
    method _check_param (line 400) | def _check_param(
    method _solve (line 418) | async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
    method _check (line 424) | async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
  class StateParam (line 431) | class StateParam(Param):
    method __repr__ (line 439) | def __repr__(self) -> str:
    method _check_param (line 444) | def _check_param(
    method _solve (line 457) | async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
  class MatcherParam (line 463) | class MatcherParam(Param):
    method __init__ (line 471) | def __init__(self, *args, checker: ModelField | None = None, **kwargs:...
    method __repr__ (line 475) | def __repr__(self) -> str:
    method _check_param (line 484) | def _check_param(
    method _solve (line 502) | async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
    method _check (line 508) | async def _check(  # pyright: ignore[reportIncompatibleMethodOverride]
  class ArgInner (line 515) | class ArgInner:
    method __init__ (line 516) | def __init__(
    method __repr__ (line 522) | def __repr__(self) -> str:
  function Arg (line 526) | def Arg(key: str | None = None) -> Any:
  function ArgStr (line 531) | def ArgStr(key: str | None = None) -> str:
  function ArgPlainText (line 536) | def ArgPlainText(key: str | None = None) -> str:
  function ArgPromptResult (line 541) | def ArgPromptResult(key: str | None = None) -> Any:
  class ArgParam (line 546) | class ArgParam(Param):
    method __init__ (line 555) | def __init__(
    method __repr__ (line 566) | def __repr__(self) -> str:
    method _check_param (line 571) | def _check_param(
    method _solve (line 581) | async def _solve(  # pyright: ignore[reportIncompatibleMethodOverride]
    method _solve_message (line 595) | def _solve_message(self, matcher: "Matcher") -> "Message | None":
    method _solve_str (line 598) | def _solve_str(self, matcher: "Matcher") -> str | None:
    method _solve_plaintext (line 602) | def _solve_plaintext(self, matcher: "Matcher") -> str | None:
    method _solve_prompt (line 606) | def _solve_prompt(self, matcher: "Matcher") -> Any | None:
  class ExceptionParam (line 612) | class ExceptionParam(Param):
    method __repr__ (line 620) | def __repr__(self) -> str:
    method _check_param (line 625) | def _check_param(
    method _solve (line 636) | async def _solve(self, exception: Exception | None = None, **kwargs: A...
  class DefaultParam (line 640) | class DefaultParam(Param):
    method __repr__ (line 648) | def __repr__(self) -> str:
    method _check_param (line 653) | def _check_param(
    method _solve (line 660) | async def _solve(self, **kwargs: Any) -> Any:

FILE: nonebot/internal/permission.py
  class Permission (line 16) | class Permission:
    method __init__ (line 41) | def __init__(self, *checkers: T_PermissionChecker | Dependent[bool]) -...
    method __repr__ (line 54) | def __repr__(self) -> str:
    method __call__ (line 57) | async def __call__(
    method __and__ (line 95) | def __and__(self, other: object) -> NoReturn:
    method __or__ (line 98) | def __or__(self, other: "Permission | T_PermissionChecker | None") -> ...
    method __ror__ (line 106) | def __ror__(self, other: "Permission | T_PermissionChecker | None") ->...
  class User (line 115) | class User:
    method __init__ (line 125) | def __init__(self, users: tuple[str, ...], perm: Permission | None = N...
    method __repr__ (line 129) | def __repr__(self) -> str:
    method __call__ (line 136) | async def __call__(self, bot: Bot, event: Event) -> bool:
    method _clean_permission (line 146) | def _clean_permission(cls, perm: Permission) -> Permission | None:
    method from_event (line 154) | def from_event(cls, event: Event, perm: Permission | None = None) -> S...
    method from_permission (line 166) | def from_permission(cls, *users: str, perm: Permission | None = None) ...
  function USER (line 178) | def USER(*users: str, perm: Permission | None = None):

FILE: nonebot/internal/rule.py
  class Rule (line 15) | class Rule:
    method __init__ (line 41) | def __init__(self, *checkers: T_RuleChecker | Dependent[bool]) -> None:
    method __repr__ (line 54) | def __repr__(self) -> str:
    method __call__ (line 57) | async def __call__(
    method __and__ (line 104) | def __and__(self, other: "Rule | T_RuleChecker | None") -> "Rule":
    method __rand__ (line 112) | def __rand__(self, other: "Rule | T_RuleChecker | None") -> "Rule":
    method __or__ (line 120) | def __or__(self, other: object) -> NoReturn:

FILE: nonebot/log.py
  class LoguruHandler (line 52) | class LoguruHandler(logging.Handler):  # pragma: no cover
    method emit (line 55) | def emit(self, record: logging.LogRecord):
  function default_filter (line 71) | def default_filter(record: "Record"):

FILE: nonebot/message.py
  function event_preprocessor (line 92) | def event_preprocessor(func: T_EventPreProcessor) -> T_EventPreProcessor:
  function event_postprocessor (line 103) | def event_postprocessor(func: T_EventPostProcessor) -> T_EventPostProces...
  function run_preprocessor (line 114) | def run_preprocessor(func: T_RunPreProcessor) -> T_RunPreProcessor:
  function run_postprocessor (line 125) | def run_postprocessor(func: T_RunPostProcessor) -> T_RunPostProcessor:
  function _handle_ignored_exception (line 136) | def _handle_ignored_exception(
  function _handle_exception (line 145) | def _handle_exception(msg: str) -> Callable[[BaseExceptionGroup[Exceptio...
  function _apply_event_preprocessors (line 153) | async def _apply_event_preprocessors(
  function _apply_event_postprocessors (line 210) | async def _apply_event_postprocessors(
  function _apply_run_preprocessors (line 256) | async def _apply_run_preprocessors(
  function _apply_run_postprocessors (line 315) | async def _apply_run_postprocessors(
  function _check_matcher (line 364) | async def _check_matcher(
  function _run_matcher (line 415) | async def _run_matcher(
  function check_and_run_matcher (line 481) | async def check_and_run_matcher(
  function handle_event (line 519) | async def handle_event(bot: "Bot", event: "Event") -> None:

FILE: nonebot/params.py
  function _event_type (line 50) | async def _event_type(event: Event) -> str:
  function EventType (line 54) | def EventType() -> str:
  function _event_message (line 59) | async def _event_message(event: Event) -> Message:
  function EventMessage (line 63) | def EventMessage() -> Any:
  function _event_plain_text (line 68) | async def _event_plain_text(event: Event) -> str:
  function EventPlainText (line 72) | def EventPlainText() -> str:
  function _event_to_me (line 77) | async def _event_to_me(event: Event) -> bool:
  function EventToMe (line 81) | def EventToMe() -> bool:
  function _command (line 86) | def _command(state: T_State) -> Message:
  function Command (line 90) | def Command() -> tuple[str, ...]:
  function _raw_command (line 95) | def _raw_command(state: T_State) -> Message:
  function RawCommand (line 99) | def RawCommand() -> str:
  function _command_arg (line 104) | def _command_arg(state: T_State) -> Message:
  function CommandArg (line 108) | def CommandArg() -> Any:
  function _command_start (line 113) | def _command_start(state: T_State) -> str:
  function CommandStart (line 117) | def CommandStart() -> str:
  function _command_whitespace (line 122) | def _command_whitespace(state: T_State) -> str:
  function CommandWhitespace (line 126) | def CommandWhitespace() -> str:
  function _shell_command_args (line 131) | def _shell_command_args(state: T_State) -> Any:
  function ShellCommandArgs (line 135) | def ShellCommandArgs() -> Any:
  function _shell_command_argv (line 140) | def _shell_command_argv(state: T_State) -> list[str | MessageSegment]:
  function ShellCommandArgv (line 144) | def ShellCommandArgv() -> Any:
  function _regex_matched (line 149) | def _regex_matched(state: T_State) -> Match[str]:
  function RegexMatched (line 153) | def RegexMatched() -> Match[str]:
  function _regex_str (line 158) | def _regex_str(
  function RegexStr (line 170) | def RegexStr(group: Literal[0] = 0, /) -> str: ...
  function RegexStr (line 174) | def RegexStr(group: str | int, /) -> str | Any: ...
  function RegexStr (line 178) | def RegexStr(
  function RegexStr (line 183) | def RegexStr(*groups: str | int) -> str | tuple[str | Any, ...] | Any:
  function _regex_group (line 188) | def _regex_group(state: T_State) -> tuple[Any, ...]:
  function RegexGroup (line 192) | def RegexGroup() -> tuple[Any, ...]:
  function _regex_dict (line 197) | def _regex_dict(state: T_State) -> dict[str, Any]:
  function RegexDict (line 201) | def RegexDict() -> dict[str, Any]:
  function _startswith (line 206) | def _startswith(state: T_State) -> str:
  function Startswith (line 210) | def Startswith() -> str:
  function _endswith (line 215) | def _endswith(state: T_State) -> str:
  function Endswith (line 219) | def Endswith() -> str:
  function _fullmatch (line 224) | def _fullmatch(state: T_State) -> str:
  function Fullmatch (line 228) | def Fullmatch() -> str:
  function _keyword (line 233) | def _keyword(state: T_State) -> str:
  function Keyword (line 237) | def Keyword() -> str:
  function Received (line 242) | def Received(id: str | None = None, default: Any = None) -> Any:
  function LastReceived (line 251) | def LastReceived(default: Any = None) -> Any:
  function ReceivePromptResult (line 260) | def ReceivePromptResult(id: str | None = None) -> Any:
  function PausePromptResult (line 271) | def PausePromptResult() -> Any:

FILE: nonebot/permission.py
  class Message (line 21) | class Message:
    method __repr__ (line 26) | def __repr__(self) -> str:
    method __call__ (line 29) | async def __call__(self, type: str = EventType()) -> bool:
  class Notice (line 33) | class Notice:
    method __repr__ (line 38) | def __repr__(self) -> str:
    method __call__ (line 41) | async def __call__(self, type: str = EventType()) -> bool:
  class Request (line 45) | class Request:
    method __repr__ (line 50) | def __repr__(self) -> str:
    method __call__ (line 53) | async def __call__(self, type: str = EventType()) -> bool:
  class MetaEvent (line 57) | class MetaEvent:
    method __repr__ (line 62) | def __repr__(self) -> str:
    method __call__ (line 65) | async def __call__(self, type: str = EventType()) -> bool:
  class SuperUser (line 91) | class SuperUser:
    method __repr__ (line 96) | def __repr__(self) -> str:
    method __call__ (line 99) | async def __call__(self, bot: Bot, event: Event) -> bool:

FILE: nonebot/plugin/__init__.py
  function _module_name_to_plugin_name (line 61) | def _module_name_to_plugin_name(module_name: str) -> str:
  function _controlled_modules (line 65) | def _controlled_modules() -> dict[str, str]:
  function _find_parent_plugin_id (line 73) | def _find_parent_plugin_id(
  function _module_name_to_plugin_id (line 87) | def _module_name_to_plugin_id(
  function _new_plugin (line 96) | def _new_plugin(
  function _revert_plugin (line 127) | def _revert_plugin(plugin: "Plugin") -> None:
  function get_plugin (line 135) | def get_plugin(plugin_id: str) -> "Plugin | None":
  function get_plugin_by_module_name (line 148) | def get_plugin_by_module_name(module_name: str) -> "Plugin | None":
  function get_loaded_plugins (line 164) | def get_loaded_plugins() -> set["Plugin"]:
  function get_available_plugin_names (line 169) | def get_available_plugin_names() -> set[str]:
  function get_plugin_config (line 174) | def get_plugin_config(config: type[C]) -> C:

FILE: nonebot/plugin/load.py
  function load_plugin (line 29) | def load_plugin(module_path: str | Path) -> Plugin | None:
  function load_plugins (line 46) | def load_plugins(*plugin_dir: str) -> set[Plugin]:
  function load_all_plugins (line 57) | def load_all_plugins(
  function load_from_json (line 71) | def load_from_json(file_path: str, encoding: str = "utf-8") -> set[Plugin]:
  function load_from_toml (line 102) | def load_from_toml(file_path: str, encoding: str = "utf-8") -> set[Plugin]:
  function load_builtin_plugin (line 161) | def load_builtin_plugin(name: str) -> Plugin | None:
  function load_builtin_plugins (line 170) | def load_builtin_plugins(*plugins: str) -> set[Plugin]:
  function _find_manager_by_name (line 179) | def _find_manager_by_name(name: str) -> PluginManager | None:
  function require (line 188) | def require(name: str) -> ModuleType:
  function inherit_supported_adapters (line 219) | def inherit_supported_adapters(*names: str) -> set[str] | None:

FILE: nonebot/plugin/manager.py
  class PluginManager (line 35) | class PluginManager:
    method __init__ (line 43) | def __init__(
    method __repr__ (line 57) | def __repr__(self) -> str:
    method third_party_plugins (line 61) | def third_party_plugins(self) -> set[str]:
    method searched_plugins (line 66) | def searched_plugins(self) -> set[str]:
    method available_plugins (line 71) | def available_plugins(self) -> set[str]:
    method controlled_modules (line 76) | def controlled_modules(self) -> dict[str, str]:
    method _previous_controlled_modules (line 84) | def _previous_controlled_modules(self) -> dict[str, str]:
    method _prepare_plugins (line 97) | def _prepare_plugins(self) -> set[str]:
    method load_plugin (line 156) | def load_plugin(self, name: str) -> Plugin | None:
    method load_all_plugins (line 201) | def load_all_plugins(self) -> set[Plugin]:
  class PluginFinder (line 209) | class PluginFinder(MetaPathFinder):
    method find_spec (line 210) | def find_spec(
  class PluginLoader (line 231) | class PluginLoader(SourceFileLoader):
    method __init__ (line 232) | def __init__(self, manager: PluginManager, fullname: str, path: str) -...
    method create_module (line 237) | def create_module(self, spec) -> ModuleType | None:
    method exec_module (line 244) | def exec_module(self, module: ModuleType) -> None:

FILE: nonebot/plugin/model.py
  class PluginMetadata (line 27) | class PluginMetadata:
    method get_supported_adapters (line 52) | def get_supported_adapters(self) -> set[Type["Adapter"]] | None:  # no...
  class Plugin (line 67) | class Plugin:
    method id_ (line 88) | def id_(self) -> str:

FILE: nonebot/plugin/on.py
  function store_matcher (line 40) | def store_matcher(matcher: type[Matcher]) -> None:
  function get_matcher_plugin (line 51) | def get_matcher_plugin(depth: int = 1) -> Plugin | None:  # pragma: no c...
  function get_matcher_module (line 66) | def get_matcher_module(depth: int = 1) -> ModuleType | None:  # pragma: ...
  function get_matcher_source (line 81) | def get_matcher_source(depth: int = 0) -> MatcherSource | None:
  function on (line 114) | def on(
  function on_metaevent (line 156) | def on_metaevent(*args, _depth: int = 0, **kwargs) -> type[Matcher]:
  function on_message (line 172) | def on_message(*args, _depth: int = 0, **kwargs) -> type[Matcher]:
  function on_notice (line 189) | def on_notice(*args, _depth: int = 0, **kwargs) -> type[Matcher]:
  function on_request (line 205) | def on_request(*args, _depth: int = 0, **kwargs) -> type[Matcher]:
  function on_startswith (line 221) | def on_startswith(
  function on_endswith (line 245) | def on_endswith(
  function on_fullmatch (line 269) | def on_fullmatch(
  function on_keyword (line 293) | def on_keyword(
  function on_command (line 315) | def on_command(
  function on_shell_command (line 350) | def on_shell_command(
  function on_regex (line 387) | def on_regex(
  function on_type (line 413) | def on_type(
  class _Group (line 437) | class _Group:
    method __init__ (line 438) | def __init__(self, **kwargs):
    method _get_final_kwargs (line 445) | def _get_final_kwargs(
  class CommandGroup (line 463) | class CommandGroup(_Group):
    method __init__ (line 479) | def __init__(
    method __repr__ (line 488) | def __repr__(self) -> str:
    method command (line 491) | def command(self, cmd: str | tuple[str, ...], **kwargs) -> type[Matcher]:
    method shell_command (line 518) | def shell_command(self, cmd: str | tuple[str, ...], **kwargs) -> type[...
  class MatcherGroup (line 546) | class MatcherGroup(_Group):
    method __repr__ (line 549) | def __repr__(self) -> str:
    method on (line 552) | def on(self, **kwargs) -> type[Matcher]:
    method on_metaevent (line 570) | def on_metaevent(self, **kwargs) -> type[Matcher]:
    method on_message (line 588) | def on_message(self, **kwargs) -> type[Matcher]:
    method on_notice (line 606) | def on_notice(self, **kwargs) -> type[Matcher]:
    method on_request (line 624) | def on_request(self, **kwargs) -> type[Matcher]:
    method on_startswith (line 642) | def on_startswith(self, msg: str | tuple[str, ...], **kwargs) -> type[...
    method on_endswith (line 662) | def on_endswith(self, msg: str | tuple[str, ...], **kwargs) -> type[Ma...
    method on_fullmatch (line 682) | def on_fullmatch(self, msg: str | tuple[str, ...], **kwargs) -> type[M...
    method on_keyword (line 702) | def on_keyword(self, keywords: set[str], **kwargs) -> type[Matcher]:
    method on_command (line 721) | def on_command(
    method on_shell_command (line 752) | def on_shell_command(
    method on_regex (line 784) | def on_regex(
    method on_type (line 808) | def on_type(

FILE: nonebot/plugin/on.pyi
  function store_matcher (line 15) | def store_matcher(matcher: type[Matcher]) -> None: ...
  function get_matcher_plugin (line 16) | def get_matcher_plugin(depth: int = ...) -> Plugin | None: ...
  function get_matcher_module (line 17) | def get_matcher_module(depth: int = ...) -> ModuleType | None: ...
  function get_matcher_source (line 18) | def get_matcher_source(depth: int = ...) -> MatcherSource | None: ...
  function on (line 19) | def on(
  function on_metaevent (line 31) | def on_metaevent(
  function on_message (line 42) | def on_message(
  function on_notice (line 53) | def on_notice(
  function on_request (line 64) | def on_request(
  function on_startswith (line 75) | def on_startswith(
  function on_endswith (line 88) | def on_endswith(
  function on_fullmatch (line 101) | def on_fullmatch(
  function on_keyword (line 114) | def on_keyword(
  function on_command (line 126) | def on_command(
  function on_shell_command (line 140) | def on_shell_command(
  function on_regex (line 154) | def on_regex(
  function on_type (line 167) | def on_type(
  class _Group (line 180) | class _Group:
    method _get_final_kwargs (line 183) | def _get_final_kwargs(
  class CommandGroup (line 187) | class CommandGroup(_Group):
    method __init__ (line 190) | def __init__(
    method command (line 204) | def command(
    method shell_command (line 219) | def shell_command(
  class MatcherGroup (line 235) | class MatcherGroup(_Group):
    method __init__ (line 236) | def __init__(
    method on (line 249) | def on(
    method on_metaevent (line 262) | def on_metaevent(
    method on_message (line 274) | def on_message(
    method on_notice (line 286) | def on_notice(
    method on_request (line 298) | def on_request(
    method on_startswith (line 310) | def on_startswith(
    method on_endswith (line 324) | def on_endswith(
    method on_fullmatch (line 338) | def on_fullmatch(
    method on_keyword (line 352) | def on_keyword(
    method on_command (line 365) | def on_command(
    method on_shell_command (line 380) | def on_shell_command(
    method on_regex (line 395) | def on_regex(
    method on_type (line 409) | def on_type(

FILE: nonebot/plugins/echo.py
  function handle_echo (line 21) | async def handle_echo(message: Message = CommandArg()):

FILE: nonebot/plugins/single_session.py
  function matcher_mutex (line 21) | async def matcher_mutex(event: Event) -> AsyncGenerator[bool, None]:
  function preprocess (line 39) | async def preprocess(mutex: bool = Depends(matcher_mutex)):

FILE: nonebot/rule.py
  class CMD_RESULT (line 61) | class CMD_RESULT(TypedDict):
  class TRIE_VALUE (line 69) | class TRIE_VALUE(NamedTuple):
  class TrieRule (line 77) | class TrieRule:
    method add_prefix (line 81) | def add_prefix(cls, prefix: str, value: TRIE_VALUE) -> None:
    method get_value (line 88) | def get_value(cls, bot: Bot, event: Event, state: T_State) -> CMD_RESULT:
  class StartswithRule (line 138) | class StartswithRule:
    method __init__ (line 148) | def __init__(self, msg: tuple[str, ...], ignorecase: bool = False):
    method __repr__ (line 152) | def __repr__(self) -> str:
    method __eq__ (line 155) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 162) | def __hash__(self) -> int:
    method __call__ (line 165) | async def __call__(self, event: Event, state: T_State) -> bool:
  function startswith (line 180) | def startswith(msg: str | tuple[str, ...], ignorecase: bool = False) -> ...
  class EndswithRule (line 193) | class EndswithRule:
    method __init__ (line 203) | def __init__(self, msg: tuple[str, ...], ignorecase: bool = False):
    method __repr__ (line 207) | def __repr__(self) -> str:
    method __eq__ (line 210) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 217) | def __hash__(self) -> int:
    method __call__ (line 220) | async def __call__(self, event: Event, state: T_State) -> bool:
  function endswith (line 235) | def endswith(msg: str | tuple[str, ...], ignorecase: bool = False) -> Rule:
  class FullmatchRule (line 248) | class FullmatchRule:
    method __init__ (line 258) | def __init__(self, msg: tuple[str, ...], ignorecase: bool = False):
    method __repr__ (line 262) | def __repr__(self) -> str:
    method __eq__ (line 265) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 272) | def __hash__(self) -> int:
    method __call__ (line 275) | async def __call__(self, event: Event, state: T_State) -> bool:
  function fullmatch (line 289) | def fullmatch(msg: str | tuple[str, ...], ignorecase: bool = False) -> R...
  class KeywordsRule (line 302) | class KeywordsRule:
    method __init__ (line 311) | def __init__(self, *keywords: str):
    method __repr__ (line 314) | def __repr__(self) -> str:
    method __eq__ (line 317) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 322) | def __hash__(self) -> int:
    method __call__ (line 325) | async def __call__(self, event: Event, state: T_State) -> bool:
  function keyword (line 338) | def keyword(*keywords: str) -> Rule:
  class CommandRule (line 348) | class CommandRule:
    method __init__ (line 358) | def __init__(
    method __repr__ (line 366) | def __repr__(self) -> str:
    method __eq__ (line 369) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 374) | def __hash__(self) -> int:
    method __call__ (line 377) | async def __call__(
  function command (line 392) | def command(
  class ArgumentParser (line 442) | class ArgumentParser(ArgParser):
    method parse_known_args (line 455) | def parse_known_args(
    method parse_known_args (line 462) | def parse_known_args(
    method parse_known_args (line 467) | def parse_known_args(
    method parse_known_args (line 471) | def parse_known_args(  # pyright: ignore[reportIncompatibleMethodOverr...
    method parse_args (line 478) | def parse_args(
    method parse_args (line 485) | def parse_args(
    method parse_args (line 490) | def parse_args(self, *, namespace: T) -> T: ...
    method parse_args (line 492) | def parse_args(
    method _parse_optional (line 503) | def _parse_optional(
    method _print_message (line 510) | def _print_message(self, message: str, file: IO[str] | None = None):  ...
    method exit (line 516) | def exit(self, status: int = 0, message: str | None = None):
  class ShellCommandRule (line 522) | class ShellCommandRule:
    method __init__ (line 532) | def __init__(self, cmds: list[tuple[str, ...]], parser: ArgumentParser...
    method __repr__ (line 536) | def __repr__(self) -> str:
    method __eq__ (line 539) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 546) | def __hash__(self) -> int:
    method __call__ (line 549) | async def __call__(
  function shell_command (line 589) | def shell_command(
  class RegexRule (line 657) | class RegexRule:
    method __init__ (line 667) | def __init__(self, regex: str, flags: int = 0):
    method __repr__ (line 671) | def __repr__(self) -> str:
    method __eq__ (line 674) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 681) | def __hash__(self) -> int:
    method __call__ (line 684) | async def __call__(self, event: Event, state: T_State) -> bool:
  function regex (line 696) | def regex(regex: str, flags: int | re.RegexFlag = 0) -> Rule:
  class ToMeRule (line 720) | class ToMeRule:
    method __repr__ (line 725) | def __repr__(self) -> str:
    method __eq__ (line 728) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 731) | def __hash__(self) -> int:
    method __call__ (line 734) | async def __call__(self, to_me: bool = EventToMe()) -> bool:
  function to_me (line 738) | def to_me() -> Rule:
  class IsTypeRule (line 744) | class IsTypeRule:
    method __init__ (line 749) | def __init__(self, *types: type[Event]):
    method __repr__ (line 752) | def __repr__(self) -> str:
    method __eq__ (line 755) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 758) | def __hash__(self) -> int:
    method __call__ (line 761) | async def __call__(self, event: Event) -> bool:
  function is_type (line 765) | def is_type(*types: type[Event]) -> Rule:

FILE: nonebot/typing.py
  function overrides (line 34) | def overrides(InterfaceClass: object):
  function type_has_args (line 46) | def type_has_args(type_: type[t.Any]) -> bool:
  function origin_is_union (line 50) | def origin_is_union(origin: type[t.Any] | None) -> bool:
  function origin_is_literal (line 54) | def origin_is_literal(origin: type[t.Any] | None) -> bool:
  function _literal_values (line 59) | def _literal_values(type_: type[t.Any]) -> tuple[t.Any, ...]:
  function all_literal_values (line 63) | def all_literal_values(type_: type[t.Any]) -> list[t.Any]:
  function origin_is_annotated (line 71) | def origin_is_annotated(origin: type[t.Any] | None) -> bool:
  function is_none_type (line 79) | def is_none_type(type_: type[t.Any]) -> bool:
  function is_type_alias_type (line 86) | def is_type_alias_type(type_: type[t.Any]) -> bool:
  function is_type_alias_type (line 92) | def is_type_alias_type(type_: type[t.Any]) -> bool:
  function evaluate_forwardref (line 96) | def evaluate_forwardref(
  class StateFlag (line 108) | class StateFlag:
    method __repr__ (line 109) | def __repr__(self) -> str:

FILE: nonebot/utils.py
  function escape_tag (line 60) | def escape_tag(s: str) -> str:
  function deep_update (line 71) | def deep_update(
  function lenient_issubclass (line 89) | def lenient_issubclass(
  function generic_check_issubclass (line 99) | def generic_check_issubclass(
  function type_is_complex (line 152) | def type_is_complex(type_: type[Any]) -> bool:
  function _type_is_complex_inner (line 158) | def _type_is_complex_inner(type_: type[Any] | None) -> bool:
  function is_coroutine_callable (line 167) | def is_coroutine_callable(call: Callable[..., Any]) -> bool:
  function is_gen_callable (line 177) | def is_gen_callable(call: Callable[..., Any]) -> bool:
  function is_async_gen_callable (line 185) | def is_async_gen_callable(call: Callable[..., Any]) -> bool:
  function run_sync (line 193) | def run_sync(call: Callable[P, R]) -> Callable[P, Coroutine[None, None, ...
  function run_sync_ctx_manager (line 210) | async def run_sync_ctx_manager(
  function run_coro_with_catch (line 225) | async def run_coro_with_catch(
  function run_coro_with_catch (line 233) | async def run_coro_with_catch(
  function run_coro_with_catch (line 240) | async def run_coro_with_catch(
  function run_coro_with_shield (line 262) | async def run_coro_with_shield(coro: Coroutine[Any, Any, T]) -> T:
  function flatten_exception_group (line 278) | def flatten_exception_group(
  function get_name (line 288) | def get_name(obj: Any) -> str:
  function path_to_module_name (line 295) | def path_to_module_name(path: Path) -> str:
  function resolve_dot_notation (line 304) | def resolve_dot_notation(
  class classproperty (line 320) | class classproperty(Generic[T]):
    method __init__ (line 323) | def __init__(self, func: Callable[[Any], T]) -> None:
    method __get__ (line 326) | def __get__(self, instance: Any, owner: type[Any] | None = None) -> T:
  class DataclassEncoder (line 330) | class DataclassEncoder(json.JSONEncoder):
    method default (line 334) | def default(self, o):
  function logger_wrapper (line 340) | def logger_wrapper(logger_name: str):

FILE: packages/nonebot-plugin-docs/nonebot_plugin_docs/__init__.py
  function init (line 18) | def init():

FILE: packages/nonebot-plugin-docs/nonebot_plugin_docs/drivers/fastapi.py
  function register_route (line 8) | def register_route(driver: Driver):

FILE: tests/conftest.py
  function pytest_configure (line 33) | def pytest_configure(config: pytest.Config) -> None:
  function load_driver (line 38) | def load_driver(request: pytest.FixtureRequest) -> Driver:
  function anyio_backend (line 49) | def anyio_backend(request: pytest.FixtureRequest):
  function run_once (line 53) | def run_once(func: Callable[P, R]) -> Callable[P, R]:
  function load_plugin (line 70) | def load_plugin(anyio_backend, nonebug_init: None) -> set["Plugin"]:
  function load_builtin_plugin (line 84) | def load_builtin_plugin(anyio_backend, nonebug_init: None) -> set["Plugi...
  function server (line 90) | def server() -> Generator[BaseWSGIServer, None, None]:
  function server_url (line 102) | def server_url(server: BaseWSGIServer) -> URL:

FILE: tests/fake_server.py
  function json_safe (line 23) | def json_safe(string, content_type="application/octet-stream") -> str:
  function flattern (line 39) | def flattern(d: "MultiDict[K, V]") -> dict[K, V | list[V]]:
  function http_echo (line 43) | def http_echo(request: Request) -> Response:
  function websocket_echo (line 82) | def websocket_echo(request: Request) -> Response:
  function request_handler (line 137) | def request_handler(request: Request) -> Response:

FILE: tests/plugins/export.py
  function test (line 1) | def test():

FILE: tests/plugins/matcher/matcher_permission.py
  function _ (line 17) | async def _() -> Permission:

FILE: tests/plugins/matcher/matcher_process.py
  function handle (line 10) | async def handle():
  function got (line 19) | async def got(key1: str = ArgStr(), key2: str = ArgStr()):
  function receive (line 32) | async def receive(
  function combine (line 47) | async def combine(a: str = ArgStr(), b: str = ArgStr(), r: Event = Recei...
  function preset (line 64) | async def preset(matcher: Matcher, message: Message = EventMessage()):
  function reject_preset (line 70) | async def reject_preset(a: str = ArgStr(), b: str = ArgStr()):
  class FakeEvent (line 81) | class FakeEvent(Event): ...
  function overload (line 85) | async def overload(event: FakeEvent):
  function finish (line 90) | async def finish():

FILE: tests/plugins/matcher/matcher_type.py
  function _ (line 9) | async def _() -> str:

FILE: tests/plugins/metadata.py
  class Config (line 7) | class Config(BaseModel):
  class FakeAdapter (line 11) | class FakeAdapter(Adapter): ...

FILE: tests/plugins/param/param_arg.py
  function arg (line 7) | async def arg(key: Message = Arg()) -> Message:
  function arg_str (line 11) | async def arg_str(key: str = ArgStr()) -> str:
  function arg_plain_text (line 15) | async def arg_plain_text(key: str = ArgPlainText()) -> str:
  function annotated_arg (line 19) | async def annotated_arg(key: Annotated[Message, Arg()]) -> Message:
  function annotated_arg_str (line 23) | async def annotated_arg_str(key: Annotated[str, ArgStr()]) -> str:
  function annotated_arg_plain_text (line 27) | async def annotated_arg_plain_text(key: Annotated[str, ArgPlainText()]) ...
  function annotated_arg_prompt_result (line 31) | async def annotated_arg_prompt_result(key: Annotated[Any, ArgPromptResul...
  function annotated_prior_arg (line 36) | async def annotated_prior_arg(key: Annotated[str, ArgStr("foo")] = ArgPl...
  function annotated_multi_arg (line 40) | async def annotated_multi_arg(

FILE: tests/plugins/param/param_bot.py
  function get_bot (line 6) | async def get_bot(b: Bot) -> Bot:
  function postpone_bot (line 10) | async def postpone_bot(b: "Bot") -> Bot:
  function legacy_bot (line 14) | async def legacy_bot(bot):
  function not_legacy_bot (line 18) | async def not_legacy_bot(bot: int): ...
  class FooBot (line 21) | class FooBot(Bot): ...
  function sub_bot (line 24) | async def sub_bot(b: FooBot) -> FooBot:
  class BarBot (line 28) | class BarBot(Bot): ...
  function union_bot (line 31) | async def union_bot(b: FooBot | BarBot) -> FooBot | BarBot:
  function generic_bot (line 38) | async def generic_bot(b: B) -> B:
  function generic_bot_none (line 45) | async def generic_bot_none(b: CB) -> CB:
  function not_bot (line 49) | async def not_bot(b: int | Bot): ...

FILE: tests/plugins/param/param_default.py
  function default (line 1) | async def default(value: int = 1) -> int:

FILE: tests/plugins/param/param_depend.py
  function dependency (line 16) | def dependency():
  function parameterless (line 21) | def parameterless():
  function gen_sync (line 26) | def gen_sync():
  function gen_async (line 30) | async def gen_async():
  class ClassDependency (line 35) | class ClassDependency:
  class FooBot (line 40) | class FooBot(Bot): ...
  function sub_bot (line 43) | async def sub_bot(b: FooBot) -> FooBot:
  function depends (line 49) | async def depends(x: int = Depends(dependency)):
  function depends_cache (line 55) | async def depends_cache(y: int = Depends(dependency, use_cache=True)):
  function class_depend (line 61) | async def class_depend(c: ClassDependency = Depends()):
  function annotated_depend (line 66) | async def annotated_depend(x: Annotated[int, Depends(dependency)]):
  function annotated_class_depend (line 71) | async def annotated_class_depend(c: Annotated[ClassDependency, Depends()]):
  function annotated_prior_depend (line 76) | async def annotated_prior_depend(
  function annotated_multi_depend (line 82) | async def annotated_multi_depend(
  function sub_type_mismatch (line 89) | async def sub_type_mismatch(b: FooBot = Depends(sub_bot)):
  function validate (line 94) | async def validate(x: int = Depends(lambda: "1", validate=True)):
  function validate_fail (line 98) | async def validate_fail(x: int = Depends(lambda: "not_number", validate=...
  function validate_field (line 103) | async def validate_field(x: int = Depends(lambda: "1", validate=Field(gt...
  function validate_field_fail (line 107) | async def validate_field_fail(x: int = Depends(lambda: "0", validate=Fie...
  function _dep (line 111) | async def _dep():
  function _dep_mismatch (line 116) | def _dep_mismatch():
  function cache_exception_func1 (line 120) | async def cache_exception_func1(
  function cache_exception_func2 (line 127) | async def cache_exception_func2(

FILE: tests/plugins/param/param_event.py
  function event (line 7) | async def event(e: Event) -> Event:
  function postpone_event (line 11) | async def postpone_event(e: "Event") -> Event:
  function legacy_event (line 15) | async def legacy_event(event):
  function not_legacy_event (line 19) | async def not_legacy_event(event: int): ...
  class FooEvent (line 22) | class FooEvent(Event): ...
  function sub_event (line 25) | async def sub_event(e: FooEvent) -> FooEvent:
  class BarEvent (line 29) | class BarEvent(Event): ...
  function union_event (line 32) | async def union_event(e: FooEvent | BarEvent) -> FooEvent | BarEvent:
  function generic_event (line 39) | async def generic_event(e: E) -> E:
  function generic_event_none (line 46) | async def generic_event_none(e: CE) -> CE:
  function not_event (line 50) | async def not_event(e: int | Event): ...
  function event_type (line 53) | async def event_type(t: str = EventType()) -> str:
  function event_message (line 57) | async def event_message(msg: Message = EventMessage()) -> Message:
  function event_plain_text (line 61) | async def event_plain_text(text: str = EventPlainText()) -> str:
  function event_to_me (line 65) | async def event_to_me(to_me: bool = EventToMe()) -> bool:

FILE: tests/plugins/param/param_exception.py
  function exc (line 1) | async def exc(e: Exception, x: ValueError | TypeError) -> Exception:
  function legacy_exc (line 6) | async def legacy_exc(exception) -> Exception:

FILE: tests/plugins/param/param_matcher.py
  function matcher (line 13) | async def matcher(m: Matcher) -> Matcher:
  function postpone_matcher (line 17) | async def postpone_matcher(m: "Matcher") -> Matcher:
  function legacy_matcher (line 21) | async def legacy_matcher(matcher):
  function not_legacy_matcher (line 25) | async def not_legacy_matcher(matcher: int): ...
  class FooMatcher (line 28) | class FooMatcher(Matcher): ...
  function sub_matcher (line 31) | async def sub_matcher(m: FooMatcher) -> FooMatcher:
  class BarMatcher (line 35) | class BarMatcher(Matcher): ...
  function union_matcher (line 38) | async def union_matcher(
  function generic_matcher (line 47) | async def generic_matcher(m: M) -> M:
  function generic_matcher_none (line 54) | async def generic_matcher_none(m: CM) -> CM:
  function not_matcher (line 58) | async def not_matcher(m: int | Matcher): ...
  function receive (line 61) | async def receive(e: Event = Received("test")) -> Event:
  function last_receive (line 65) | async def last_receive(e: Event = LastReceived()) -> Event:
  function receive_prompt_result (line 69) | async def receive_prompt_result(result: Any = ReceivePromptResult("test"...
  function pause_prompt_result (line 73) | async def pause_prompt_result(result: Any = PausePromptResult()) -> Any:

FILE: tests/plugins/param/param_state.py
  function state (line 24) | async def state(x: T_State) -> T_State:
  function postpone_state (line 28) | async def postpone_state(x: "T_State") -> T_State:
  function legacy_state (line 32) | async def legacy_state(state):
  function not_legacy_state (line 36) | async def not_legacy_state(state: int): ...
  function command (line 39) | async def command(cmd: tuple[str, ...] = Command()) -> tuple[str, ...]:
  function raw_command (line 43) | async def raw_command(raw_cmd: str = RawCommand()) -> str:
  function command_arg (line 47) | async def command_arg(cmd_arg: Message = CommandArg()) -> Message:
  function command_start (line 51) | async def command_start(start: str = CommandStart()) -> str:
  function command_whitespace (line 55) | async def command_whitespace(whitespace: str = CommandWhitespace()) -> str:
  function shell_command_args (line 59) | async def shell_command_args(
  function shell_command_argv (line 65) | async def shell_command_argv(
  function regex_dict (line 71) | async def regex_dict(regex_dict: dict = RegexDict()) -> dict:
  function regex_group (line 75) | async def regex_group(regex_group: tuple = RegexGroup()) -> tuple:
  function regex_matched (line 79) | async def regex_matched(regex_matched: Match[str] = RegexMatched()) -> M...
  function regex_str (line 83) | async def regex_str(
  function startswith (line 92) | async def startswith(startswith: str = Startswith()) -> str:
  function endswith (line 96) | async def endswith(endswith: str = Endswith()) -> str:
  function fullmatch (line 100) | async def fullmatch(fullmatch: str = Fullmatch()) -> str:
  function keyword (line 104) | async def keyword(keyword: str = Keyword()) -> str:

FILE: tests/plugins/param/priority.py
  function dependency (line 7) | def dependency():
  function complex_priority (line 11) | async def complex_priority(

FILE: tests/plugins/plugin/matchers.py
  function rule (line 24) | async def rule() -> bool:
  function permission (line 28) | async def permission() -> bool:
  function handler (line 32) | async def handler():
  function matcher_on_factory (line 54) | def matcher_on_factory() -> type[Matcher]:
  class TestEvent (line 204) | class TestEvent(Event): ...

FILE: tests/python_3_12/plugins/aliased_param/param_arg.py
  function aliased_arg (line 9) | async def aliased_arg(key: AliasedArg) -> Message:

FILE: tests/python_3_12/plugins/aliased_param/param_bot.py
  function get_aliased_bot (line 6) | async def get_aliased_bot(b: AliasedBot) -> Bot:

FILE: tests/python_3_12/plugins/aliased_param/param_depend.py
  function dependency (line 11) | def dependency():
  function aliased_depends (line 20) | async def aliased_depends(x: AliasedDepends):

FILE: tests/python_3_12/plugins/aliased_param/param_event.py
  function aliased_event (line 6) | async def aliased_event(e: AliasedEvent) -> Event:

FILE: tests/python_3_12/plugins/aliased_param/param_exception.py
  function aliased_exc (line 4) | async def aliased_exc(e: AliasedException) -> Exception:

FILE: tests/python_3_12/plugins/aliased_param/param_matcher.py
  function aliased_matcher (line 6) | async def aliased_matcher(m: AliasedMatcher) -> Matcher:

FILE: tests/python_3_12/plugins/aliased_param/param_state.py
  function aliased_state (line 6) | async def aliased_state(x: AliasedState) -> T_State:

FILE: tests/test_adapters/test_adapter.py
  function test_adapter_connect (line 20) | async def test_adapter_connect(app: App, driver: Driver):
  function test_adapter_server (line 76) | def test_adapter_server(driver: Driver):
  function test_adapter_http_client (line 143) | async def test_adapter_http_client(driver: Driver):
  function test_adapter_websocket_client (line 190) | async def test_adapter_websocket_client(driver: Driver):

FILE: tests/test_adapters/test_bot.py
  function test_bot_call_api (line 12) | async def test_bot_call_api(app: App):
  function test_bot_calling_api_hook_simple (line 28) | async def test_bot_calling_api_hook_simple(app: App):
  function test_bot_calling_api_hook_mock (line 54) | async def test_bot_calling_api_hook_mock(app: App):
  function test_bot_calling_api_hook_multi_mock (line 81) | async def test_bot_calling_api_hook_multi_mock(app: App):
  function test_bot_called_api_hook_simple (line 121) | async def test_bot_called_api_hook_simple(app: App):
  function test_bot_called_api_hook_mock (line 153) | async def test_bot_called_api_hook_mock(app: App):
  function test_bot_called_api_hook_multi_mock (line 197) | async def test_bot_called_api_hook_multi_mock(app: App):

FILE: tests/test_adapters/test_message.py
  function test_segment_data (line 9) | def test_segment_data():
  function test_segment_equal (line 20) | def test_segment_equal():
  function test_segment_add (line 32) | def test_segment_add():
  function test_segment_validate (line 50) | def test_segment_validate():
  function test_segment_join (line 68) | def test_segment_join():
  function test_segment_copy (line 87) | def test_segment_copy():
  function test_message_add (line 94) | def test_message_add():
  function test_message_getitem (line 119) | def test_message_getitem():
  function test_message_validate (line 152) | def test_message_validate():
  function test_message_contains (line 175) | def test_message_contains():
  function test_message_only (line 201) | def test_message_only():
  function test_message_join (line 233) | def test_message_join():
  function test_message_include (line 252) | def test_message_include():
  function test_message_exclude (line 270) | def test_message_exclude():

FILE: tests/test_adapters/test_template.py
  function test_template_basis (line 7) | def test_template_basis():
  function test_template_message (line 13) | def test_template_message():
  function test_rich_template_message (line 36) | def test_rich_template_message():
  function test_message_injection (line 53) | def test_message_injection():
  function test_malformed_template (line 60) | def test_malformed_template():

FILE: tests/test_broadcast.py
  function _dependency (line 23) | async def _dependency() -> int:
  function test_event_preprocessor (line 28) | async def test_event_preprocessor(app: App, monkeypatch: pytest.MonkeyPa...
  function test_event_preprocessor_ignore (line 61) | async def test_event_preprocessor_ignore(app: App, monkeypatch: pytest.M...
  function test_event_preprocessor_exception (line 91) | async def test_event_preprocessor_exception(
  function test_event_postprocessor (line 135) | async def test_event_postprocessor(app: App, monkeypatch: pytest.MonkeyP...
  function test_event_postprocessor_exception (line 168) | async def test_event_postprocessor_exception(
  function test_run_preprocessor (line 205) | async def test_run_preprocessor(app: App, monkeypatch: pytest.MonkeyPatch):
  function test_run_preprocessor_ignore (line 242) | async def test_run_preprocessor_ignore(app: App, monkeypatch: pytest.Mon...
  function test_run_preprocessor_exception (line 272) | async def test_run_preprocessor_exception(
  function test_run_postprocessor (line 316) | async def test_run_postprocessor(app: App, monkeypatch: pytest.MonkeyPat...
  function test_run_postprocessor_exception (line 354) | async def test_run_postprocessor_exception(

FILE: tests/test_compat.py
  function test_default_config (line 22) | def test_default_config():
  function test_field_info (line 27) | def test_field_info():
  function test_field_validator (line 35) | def test_field_validator():
  function test_type_adapter (line 61) | def test_type_adapter():
  function test_model_dump (line 75) | def test_model_dump():
  function test_model_validator (line 113) | def test_model_validator():
  function test_custom_validation (line 142) | def test_custom_validation():
  function test_validate_json (line 169) | def test_validate_json():

FILE: tests/test_config.py
  class Simple (line 10) | class Simple(BaseModel):
  class Example (line 17) | class Example(BaseSettings):
    class Config (line 28) | class Config(  # pyright: ignore[reportIncompatibleVariableOverride]
  class ExampleWithoutDelimiter (line 44) | class ExampleWithoutDelimiter(Example):
    class Config (line 49) | class Config(  # pyright: ignore[reportIncompatibleVariableOverride]
  function test_config_no_env (line 55) | def test_config_no_env():
  function test_config_with_env (line 62) | def test_config_with_env():
  function test_config_error_env (line 109) | def test_config_error_env():
  function test_config_without_delimiter (line 117) | def test_config_without_delimiter():

FILE: tests/test_driver.py
  function test_lifespan (line 35) | async def test_lifespan(driver: Driver):
  function test_http_server (line 89) | async def test_http_server(app: App, driver: Driver):
  function test_websocket_server (line 117) | async def test_websocket_server(app: App, driver: Driver):
  function test_cross_context (line 173) | async def test_cross_context(app: App, driver: Driver):
  function test_http_client (line 230) | async def test_http_client(driver: Driver, server_url: URL):
  function test_http_client_session (line 397) | async def test_http_client_session(driver: Driver, server_url: URL):
  function test_websocket_client (line 608) | async def test_websocket_client(driver: Driver, server_url: URL):
  function test_aiohttp_websocket_close_frame (line 641) | async def test_aiohttp_websocket_close_frame(msg_type: str) -> None:
  function test_combine_driver (line 684) | def test_combine_driver(driver: Driver, driver_type: str):
  function test_bot_connect_hook (line 689) | async def test_bot_connect_hook(app: App, driver: Driver):

FILE: tests/test_echo.py
  function test_echo (line 8) | async def test_echo(app: App):

FILE: tests/test_init.py
  function test_init (line 17) | def test_init():
  function test_get_driver (line 37) | def test_get_driver(monkeypatch: pytest.MonkeyPatch):
  function test_get_asgi (line 44) | def test_get_asgi():
  function test_get_app (line 51) | def test_get_app():
  function test_get_adapter (line 59) | async def test_get_adapter(app: App, monkeypatch: pytest.MonkeyPatch):
  function test_run (line 73) | def test_run(monkeypatch: pytest.MonkeyPatch):
  function test_get_bot (line 91) | def test_get_bot(app: App, monkeypatch: pytest.MonkeyPatch):

FILE: tests/test_matcher/test_matcher.py
  function test_matcher_info (line 15) | def test_matcher_info(app: App):
  function test_matcher_check (line 46) | async def test_matcher_check(app: App):
  function test_matcher_handle (line 90) | async def test_matcher_handle(app: App):
  function test_matcher_got (line 105) | async def test_matcher_got(app: App):
  function test_matcher_receive (line 127) | async def test_matcher_receive(app: App):
  function test_matcher_combine (line 144) | async def test_matcher_combine(app: App):
  function test_matcher_preset (line 167) | async def test_matcher_preset(app: App):
  function test_matcher_overload (line 185) | async def test_matcher_overload(app: App):
  function test_matcher_destroy (line 199) | async def test_matcher_destroy(app: App):
  function test_type_updater (line 213) | async def test_type_updater(app: App):
  function test_default_permission_updater (line 234) | async def test_default_permission_updater(app: App):
  function test_user_permission_updater (line 255) | async def test_user_permission_updater(app: App):
  function test_custom_permission_updater (line 277) | async def test_custom_permission_updater(app: App):
  function test_run (line 294) | async def test_run(app: App):
  function test_temp (line 325) | async def test_temp(app: App):
  function test_datetime_expire (line 338) | async def test_datetime_expire(app: App):
  function test_timedelta_expire (line 353) | async def test_timedelta_expire(app: App):

FILE: tests/test_matcher/test_provider.py
  function test_manager (line 6) | def test_manager(app: App):

FILE: tests/test_param.py
  function test_depend (line 50) | async def test_depend(app: App):
  function test_aliased_depend (line 169) | async def test_aliased_depend(app: App):
  function test_bot (line 182) | async def test_bot(app: App):
  function test_aliased_bot (line 250) | async def test_aliased_bot(app: App):
  function test_event (line 260) | async def test_event(app: App):
  function test_aliased_event (line 352) | async def test_aliased_event(app: App):
  function test_state (line 364) | async def test_state(app: App):
  function test_aliased_state (line 518) | async def test_aliased_state(app: App):
  function test_matcher (line 546) | async def test_matcher(app: App):
  function test_aliased_matcher (line 661) | async def test_aliased_matcher(app: App):
  function test_arg (line 672) | async def test_arg(app: App):
  function test_aliased_arg (line 744) | async def test_aliased_arg(app: App):
  function test_exception (line 757) | async def test_exception(app: App):
  function test_aliased_exception (line 775) | async def test_aliased_exception(app: App):
  function test_default (line 786) | async def test_default(app: App):
  function test_priority (line 793) | def test_priority():

FILE: tests/test_permission.py
  function test_permission (line 24) | async def test_permission(app: App):
  function test_message (line 57) | async def test_message(type: str, expected: bool):
  function test_notice (line 69) | async def test_notice(type: str, expected: bool):
  function test_request (line 81) | async def test_request(type: str, expected: bool):
  function test_metaevent (line 95) | async def test_metaevent(type: str, expected: bool):
  function test_superuser (line 116) | async def test_superuser(app: App, type: str, user_id: str, expected: bo...
  function test_user (line 138) | async def test_user(

FILE: tests/test_plugin/test_get.py
  function test_get_plugin (line 8) | def test_get_plugin():
  function test_get_plugin_by_module_name (line 24) | def test_get_plugin_by_module_name():
  function test_get_available_plugin (line 49) | def test_get_available_plugin():
  function test_get_plugin_config (line 63) | def test_get_plugin_config():
  function test_get_plugin_config_with_env (line 73) | def test_get_plugin_config_with_env(monkeypatch: pytest.MonkeyPatch):

FILE: tests/test_plugin/test_load.py
  function _recover (line 24) | def _recover(func: Callable[P, R]) -> Callable[P, R]:
  function test_load_plugin (line 41) | def test_load_plugin():
  function test_load_plugins (line 52) | def test_load_plugins(load_plugin: set[Plugin], load_builtin_plugin: set...
  function test_load_nested_plugin (line 75) | def test_load_nested_plugin():
  function test_load_json (line 88) | def test_load_json():
  function test_load_toml (line 96) | def test_load_toml():
  function test_bad_plugin (line 109) | def test_bad_plugin():
  function test_require_loaded (line 116) | def test_require_loaded(monkeypatch: pytest.MonkeyPatch):
  function test_require_not_loaded (line 131) | def test_require_not_loaded(monkeypatch: pytest.MonkeyPatch):
  function test_require_not_declared (line 155) | def test_require_not_declared():
  function test_require_not_found (line 165) | def test_require_not_found():
  function test_plugin_metadata (line 170) | def test_plugin_metadata():
  function test_inherit_supported_adapters_not_found (line 190) | def test_inherit_supported_adapters_not_found():
  function test_inherit_supported_adapters_combine (line 264) | def test_inherit_supported_adapters_combine(

FILE: tests/test_plugin/test_manager.py
  function test_load_plugin_name (line 4) | def test_load_plugin_name():

FILE: tests/test_plugin/test_on.py
  function test_on (line 104) | def test_on(
  function test_runtime_on (line 152) | def test_runtime_on():

FILE: tests/test_rule.py
  function test_rule (line 52) | async def test_rule(app: App):
  function test_trie (line 84) | async def test_trie(app: App):
  function test_startswith (line 164) | async def test_startswith(
  function test_endswith (line 204) | async def test_endswith(
  function test_fullmatch (line 244) | async def test_fullmatch(
  function test_keyword (line 280) | async def test_keyword(
  function test_command (line 324) | async def test_command(
  function test_shell_command (line 347) | async def test_shell_command():
  function test_regex (line 491) | async def test_regex(
  function test_to_me (line 520) | async def test_to_me(expected: bool):
  function test_is_type (line 532) | async def test_is_type():

FILE: tests/test_single_session.py
  function test_matcher_mutex (line 9) | async def test_matcher_mutex():

FILE: tests/test_utils.py
  function test_loguru_escape_tag (line 15) | def test_loguru_escape_tag():
  function test_generic_check_issubclass (line 23) | def test_generic_check_issubclass():
  function test_is_coroutine_callable (line 39) | def test_is_coroutine_callable():
  function test_is_gen_callable (line 57) | def test_is_gen_callable():
  function test_is_async_gen_callable (line 85) | def test_is_async_gen_callable():
  function test_dataclass_encoder (line 113) | def test_dataclass_encoder():

FILE: tests/utils.py
  function escape_text (line 9) | def escape_text(s: str, *, escape_comma: bool = True) -> str:
  class FakeAdapter (line 16) | class FakeAdapter(Adapter):
    method get_name (line 19) | def get_name(cls) -> str:
    method _call_api (line 23) | async def _call_api(self, bot: Bot, api: str, **data):
  class FakeMessageSegment (line 27) | class FakeMessageSegment(MessageSegment["FakeMessage"]):
    method get_message_class (line 30) | def get_message_class(cls):
    method __str__ (line 34) | def __str__(self) -> str:
    method text (line 38) | def text(cls, text: str):
    method image (line 42) | def image(url: str):
    method nested (line 46) | def nested(content: "FakeMessage"):
    method is_text (line 50) | def is_text(self) -> bool:
  class FakeMessage (line 54) | class FakeMessage(Message[FakeMessageSegment]):
    method get_segment_class (line 57) | def get_segment_class(cls):
    method _construct (line 62) | def _construct(msg: str | Iterable[Mapping]):
    method __add__ (line 71) | def __add__(self, other: str | FakeMessageSegment | Iterable[FakeMessa...
  function make_fake_event (line 76) | def make_fake_event(

FILE: website/docusaurus.config.ts
  function createConfigAsync (line 186) | async function createConfigAsync() {

FILE: website/src/components/Asciinema/container.tsx
  type AsciinemaOptions (line 5) | type AsciinemaOptions = {
  type Props (line 20) | type Props = {
  function AsciinemaContainer (line 25) | function AsciinemaContainer({

FILE: website/src/components/Asciinema/index.tsx
  function Asciinema (line 13) | function Asciinema(props: Props): React.ReactNode {

FILE: website/src/components/Form/Adapter.tsx
  function AdapterForm (line 5) | function AdapterForm(): React.ReactNode {

FILE: website/src/components/Form/Bot.tsx
  function BotForm (line 5) | function BotForm(): React.ReactNode {

FILE: website/src/components/Form/Items/Tag/index.tsx
  type Props (line 14) | type Props = {
  function TagFormItem (line 19) | function TagFormItem({

FILE: website/src/components/Form/Plugin.tsx
  function PluginForm (line 7) | function PluginForm(): React.ReactNode {

FILE: website/src/components/Form/index.tsx
  type FormItemData (line 14) | type FormItemData = {
  type FormItemGroup (line 20) | type FormItemGroup = {
  type Props (line 25) | type Props = {
  function Form (line 33) | function Form({
  function FormItem (line 124) | function FormItem({

FILE: website/src/components/Home/Feature.tsx
  type Feature (line 5) | type Feature = {
  function HomeFeature (line 13) | function HomeFeature({
  function HomeFeatureSingleColumn (line 35) | function HomeFeatureSingleColumn(props: Feature): React.ReactNode {
  function HomeFeatureDoubleColumn (line 43) | function HomeFeatureDoubleColumn({
  function HomeFeatures (line 60) | function HomeFeatures(): React.ReactNode {

FILE: website/src/components/Home/Hero.tsx
  function HomeHeroInstallButton (line 13) | function HomeHeroInstallButton(): React.ReactNode {
  function HomeHero (line 40) | function HomeHero(): React.ReactNode {

FILE: website/src/components/Home/index.tsx
  function HomeContent (line 8) | function HomeContent(): React.ReactNode {

FILE: website/src/components/Messenger/index.tsx
  type Message (line 13) | type Message = {
  function MessageBox (line 19) | function MessageBox({
  function Messenger (line 63) | function Messenger({

FILE: website/src/components/Modal/index.tsx
  type Props (line 9) | type Props = {
  function Modal (line 18) | function Modal({

FILE: website/src/components/Paginate/index.tsx
  constant MAX_LENGTH (line 11) | const MAX_LENGTH = 7;
  type Props (line 13) | type Props = Pick<
  function Paginate (line 26) | function Paginate({

FILE: website/src/components/Resource/Avatar/index.tsx
  type Props (line 5) | interface Props {
  function Avatar (line 11) | function Avatar({ authorLink, authorAvatar, className }: Props) {

FILE: website/src/components/Resource/Card/index.tsx
  type Props (line 15) | type Props = {
  function ResourceCard (line 23) | function ResourceCard({

FILE: website/src/components/Resource/DetailCard/index.tsx
  type Props (line 15) | type Props = {
  function ResourceDetailCard (line 19) | function ResourceDetailCard({ resource }: Props) {

FILE: website/src/components/Resource/DetailCard/types.ts
  type Downloads (line 1) | type Downloads = {
  type Info (line 7) | type Info = {
  type Digests (line 35) | interface Digests {
  type Releases (line 41) | type Releases = {
  type PyPIData (line 58) | type PyPIData = {

FILE: website/src/components/Resource/Tag/index.tsx
  type Props (line 11) | type Props = Tag & {
  function ResourceTag (line 16) | function ResourceTag({

FILE: website/src/components/Resource/ValidStatus/index.tsx
  type Props (line 36) | type Props = {
  function ValidDisplay (line 43) | function ValidDisplay({

FILE: website/src/components/Searcher/index.tsx
  type Props (line 10) | type Props = {
  function Searcher (line 22) | function Searcher({

FILE: website/src/components/Store/Content/Adapter.tsx
  function AdapterPage (line 21) | function AdapterPage(): React.ReactNode {

FILE: website/src/components/Store/Content/Bot.tsx
  function PluginPage (line 20) | function PluginPage(): React.ReactNode {

FILE: website/src/components/Store/Content/Driver.tsx
  function DriverPage (line 18) | function DriverPage(): React.ReactNode {

FILE: website/src/components/Store/Content/Plugin.tsx
  function PluginPage (line 25) | function PluginPage(): React.ReactNode {

FILE: website/src/components/Store/Layout.tsx
  constant SIDEBAR_ID (line 15) | const SIDEBAR_ID = "ecosystem";
  type Props (line 17) | type Props = {
  function StorePage (line 22) | function StorePage({ title, children }: Props): React.ReactNode {
  function StoreLayout (line 41) | function StoreLayout({

FILE: website/src/components/Store/Toolbar.tsx
  type Filter (line 9) | type Filter = {
  type Sorter (line 16) | type Sorter = {
  type Action (line 23) | type Action = {
  type Props (line 29) | type Props = {
  function ToolbarFilter (line 36) | function ToolbarFilter({
  function StoreToolbar (line 106) | function StoreToolbar({

FILE: website/src/components/Tag/index.tsx
  function Tag (line 11) | function Tag({

FILE: website/src/libs/color.ts
  function pickTextColor (line 6) | function pickTextColor(

FILE: website/src/libs/filter.ts
  type Filter (line 11) | type Filter<T extends Resource = Resource> = {
  function filterResources (line 124) | function filterResources<T extends Resource>(
  type useFilteredResourcesReturn (line 133) | type useFilteredResourcesReturn<T extends Resource> = {
  function useFilteredResources (line 140) | function useFilteredResources<T extends Resource>(

FILE: website/src/libs/search.ts
  type useSearchControlReturn (line 7) | type useSearchControlReturn<T extends Resource> = {
  function useSearchControl (line 18) | function useSearchControl<T extends Resource>(

FILE: website/src/libs/sorter.ts
  type SortMode (line 1) | enum SortMode {

FILE: website/src/libs/store.ts
  type RegistryDataResponseTypes (line 8) | type RegistryDataResponseTypes = {
  type RegistryDataType (line 14) | type RegistryDataType = keyof RegistryDataResponseTypes;
  type ResourceTypes (line 16) | type ResourceTypes = {
  type Resource (line 23) | type Resource = Adapter | Bot | Driver | Plugin;
  function fetchRegistryData (line 25) | async function fetchRegistryData<T extends RegistryDataType>(

FILE: website/src/libs/toolbar.ts
  type Props (line 15) | type Props<T extends Resource = Resource> = {
  type useToolbarReturns (line 20) | type useToolbarReturns = {
  function useToolbar (line 24) | function useToolbar<T extends Resource = Resource>({

FILE: website/src/libs/valid.ts
  type ValidStatus (line 1) | enum ValidStatus {

FILE: website/src/pages/index.tsx
  function Homepage (line 6) | function Homepage(): React.ReactNode {

FILE: website/src/pages/store/adapters.tsx
  function StoreAdapters (line 8) | function StoreAdapters(): React.ReactNode {

FILE: website/src/pages/store/bots.tsx
  function StoreBots (line 8) | function StoreBots(): React.ReactNode {

FILE: website/src/pages/store/drivers.tsx
  function StoreDrivers (line 8) | function StoreDrivers(): React.ReactNode {

FILE: website/src/pages/store/index.tsx
  function Store (line 5) | function Store(): React.ReactNode {

FILE: website/src/pages/store/plugins.tsx
  function StorePlugins (line 8) | function StorePlugins(): React.ReactNode {

FILE: website/src/plugins/webpack-plugin.ts
  method configureWebpack (line 8) | configureWebpack() {

FILE: website/src/theme/Footer/Copyright/index.tsx
  function FooterCopyright (line 11) | function FooterCopyright(props: Props) {

FILE: website/src/theme/Icon/Cloudflare.tsx
  type Props (line 3) | interface Props extends Omit<ComponentProps<"svg">, "viewBox"> {}
  function IconCloudflare (line 5) | function IconCloudflare(props: Props): React.ReactNode {

FILE: website/src/theme/Icon/Netlify.tsx
  type Props (line 3) | interface Props extends Omit<ComponentProps<"svg">, "viewBox"> {}
  function IconNetlify (line 5) | function IconNetlify(props: Props): React.ReactNode {

FILE: website/src/theme/Page/TOC/Container/index.tsx
  function TOCContainer (line 10) | function TOCContainer({

FILE: website/src/types/adapter.ts
  type BaseAdapter (line 3) | type BaseAdapter = {
  type Adapter (line 14) | type Adapter = { resourceType: "adapter" } & BaseAdapter;
  type AdaptersResponse (line 16) | type AdaptersResponse = BaseAdapter[];

FILE: website/src/types/bot.ts
  type BaseBot (line 3) | type BaseBot = {
  type Bot (line 12) | type Bot = { resourceType: "bot" } & BaseBot;
  type BotsResponse (line 14) | type BotsResponse = BaseBot[];

FILE: website/src/types/driver.ts
  type BaseDriver (line 3) | type BaseDriver = {
  type Driver (line 14) | type Driver = { resourceType: "driver" } & BaseDriver;
  type DriversResponse (line 16) | type DriversResponse = BaseDriver[];

FILE: website/src/types/plugin.ts
  type BasePlugin (line 3) | type BasePlugin = {
  type Plugin (line 20) | type Plugin = { resourceType: "plugin" } & BasePlugin;
  type PluginsResponse (line 22) | type PluginsResponse = BasePlugin[];

FILE: website/src/types/tag.ts
  type Tag (line 1) | type Tag = {

FILE: website/tailwind.config.ts
  function excludeThemeColor (line 8) | function excludeThemeColor(