hikari-arc 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

arc/context/base.py

@@ -10,7 +10,9 @@ from contextlib import suppress
 import attr
 import hikari
 
+from arc.abc.option import OptionType  # noqa: TCH001 Needed for tests
 from arc.errors import NoResponseIssuedError, ResponseAlreadyIssuedError
+from arc.internal.options import OPTIONTYPE_TO_TYPE, resolve_snowflake_value
 from arc.internal.types import ClientT, ResponseBuilderT
 from arc.locale import CustomLocaleRequest
 
@@ -252,6 +254,7 @@ class Context(t.Generic[ClientT]):
         "_created_at",
         "_autodefer_task",
         "_has_command_failed",
+        "_options",
     )
 
     def __init__(
@@ -260,6 +263,7 @@ class Context(t.Generic[ClientT]):
         self._client = client
         self._command = command
         self._interaction: hikari.CommandInteraction = interaction
+        self._options: t.Sequence[hikari.CommandInteractionOption] | None = None
         self._responses: t.MutableSequence[InteractionResponse] = []
         self._resp_builder: asyncio.Future[ResponseBuilderT] = asyncio.Future()
         self._issued_response: bool = False
@@ -272,11 +276,11 @@ class Context(t.Generic[ClientT]):
     def interaction(self) -> hikari.CommandInteraction:
         """The underlying interaction object.
 
-        .. warning::
+        !!! warning
             This should not be used directly in most cases, and is only exposed for advanced use cases.
 
-            If you use the interaction to create a response in a view,
-            you should disable the autodefer feature in your View.
+            If you use the interaction to create a response,
+            you should disable the autodefer feature in your command.
         """
         return self._interaction
 
@@ -404,6 +408,82 @@ class Context(t.Generic[ClientT]):
         """Gets the channel this context represents, None if in a DM. Requires application cache."""
         return self._interaction.get_channel()
 
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.ATTACHMENT]) -> hikari.Attachment | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.MENTIONABLE]) -> hikari.User | hikari.Role | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.USER]) -> hikari.User | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.ROLE]) -> hikari.Role | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.CHANNEL]) -> hikari.PartialChannel | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.STRING]) -> str | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.BOOLEAN]) -> bool | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.FLOAT]) -> float | None:
+        ...
+
+    @t.overload
+    def get_option(self, name: str, opt_type: t.Literal[OptionType.INTEGER]) -> int | None:
+        ...
+
+    def get_option(self, name: str, opt_type: OptionType) -> t.Any | None:
+        """Get the value of an option by name.
+
+        Parameters
+        ----------
+        name : str
+            The name of the option.
+        opt_type : hikari.OptionType
+            The type of the option.
+
+        Returns
+        -------
+        ValueT | None
+            The value of the option, or None if it does not exist, or is not of the correct type.
+
+        Usage
+        -----
+        ```py
+        value = ctx.get_option("name", arc.OptionType.STRING)
+        if value is None:
+            # Option does not exist or is not a string
+
+        # Do something with the value
+        print(value)
+        ```
+
+        """
+        if self._options is None:
+            return None
+
+        value = next((x.value for x in self._options if x.name == name), None)
+
+        if value is hikari.Snowflake and self._interaction.resolved is not None:
+            value = resolve_snowflake_value(value, opt_type, self._interaction.resolved)
+
+        if not isinstance(value, OPTIONTYPE_TO_TYPE[opt_type]):
+            return None
+
+        return value
+
     def loc(self, key: str, use_guild: bool = True, force_locale: hikari.Locale | None = None, **kwargs: t.Any) -> str:
         """Get a localized string using the interaction's locale.
 
@@ -578,7 +658,8 @@ class Context(t.Generic[ClientT]):
         ...
 
     async def respond_with_builder(self, builder: ResponseBuilderT) -> InteractionResponse | None:
-        """Respond to the interaction with a builder.
+        """Respond to the interaction with a builder. This method will try to turn the builder into a valid
+        response or followup, depending on the builder type and interaction state.
 
         Parameters
         ----------
@@ -593,13 +674,13 @@ class Context(t.Generic[ClientT]):
         Raises
         ------
         RuntimeError
-            The interaction was already issued an initial response.
+            The interaction was already issued an initial response and the builder can only be used for initial responses.
         """
         async with self._response_lock:
-            if self._issued_response:
+            if self._issued_response and not isinstance(builder, hikari.api.InteractionMessageBuilder):
                 raise RuntimeError("This interaction was already issued an initial response.")
 
-            if self.client.is_rest:
+            if self.client.is_rest and not self._issued_response:
                 self._resp_builder.set_result(builder)
                 self._issued_response = True
                 if not isinstance(builder, hikari.api.InteractionModalBuilder):
@@ -608,25 +689,38 @@ class Context(t.Generic[ClientT]):
                 return
 
             if isinstance(builder, hikari.api.InteractionMessageBuilder):
-                await self.interaction.create_initial_response(
-                    response_type=hikari.ResponseType.MESSAGE_CREATE,
-                    content=builder.content,
-                    tts=builder.is_tts,
-                    components=builder.components,
-                    attachments=builder.attachments,
-                    embeds=builder.embeds,
-                    mentions_everyone=builder.mentions_everyone,
-                    user_mentions=builder.user_mentions,
-                    role_mentions=builder.role_mentions,
-                    flags=builder.flags,
-                )
+                if not self._issued_response:
+                    await self.interaction.create_initial_response(
+                        response_type=hikari.ResponseType.MESSAGE_CREATE,
+                        content=builder.content,
+                        tts=builder.is_tts,
+                        components=builder.components,
+                        attachments=builder.attachments,
+                        embeds=builder.embeds,
+                        mentions_everyone=builder.mentions_everyone,
+                        user_mentions=builder.user_mentions,
+                        role_mentions=builder.role_mentions,
+                        flags=builder.flags,
+                    )
+                else:
+                    await self.interaction.execute(
+                        content=builder.content,
+                        tts=builder.is_tts,
+                        components=builder.components or hikari.UNDEFINED,
+                        attachments=builder.attachments or hikari.UNDEFINED,
+                        embeds=builder.embeds or hikari.UNDEFINED,
+                        mentions_everyone=builder.mentions_everyone,
+                        user_mentions=builder.user_mentions,
+                        role_mentions=builder.role_mentions,
+                        flags=builder.flags,
+                    )
             elif isinstance(builder, hikari.api.InteractionDeferredBuilder):
                 await self.interaction.create_initial_response(
                     response_type=hikari.ResponseType.DEFERRED_MESSAGE_CREATE, flags=builder.flags
                 )
             else:
                 await self.interaction.create_modal_response(
-                    title=builder.title, custom_id=builder.custom_id, components=builder.components
+                    title=builder.title, custom_id=builder.custom_id, components=builder.components or hikari.UNDEFINED
                 )
 
             self._issued_response = True

arc/errors.py

@@ -5,18 +5,9 @@ import typing as t
 if t.TYPE_CHECKING:
     import hikari
 
+    from arc.abc.command import CommandProto
     from arc.abc.limiter import LimiterProto
 
-__all__ = (
-    "ArcError",
-    "AutocompleteError",
-    "CommandInvokeError",
-    "ExtensionError",
-    "ExtensionLoadError",
-    "ExtensionUnloadError",
-    "NoResponseIssuedError",
-)
-
 
 class ArcError(Exception):
     """Base exception for all Arc errors."""
@@ -120,10 +111,10 @@ class UnderCooldownError(ArcError):
 
     Attributes
     ----------
-    retry_after : float
-        The amount of time in seconds until the command is off cooldown.
     limiter : arc.abc.limiter.LimiterProto
         The limiter that was rate limited.
+    retry_after : float
+        The amount of time in seconds until the command is off cooldown.
     """
 
     def __init__(self, limiter: LimiterProto[t.Any], retry_after: float, *args: t.Any) -> None:
@@ -132,6 +123,34 @@ class UnderCooldownError(ArcError):
         super().__init__(*args)
 
 
+class CommandPublishFailedError(ArcError):
+    """Raised when a command could not be published to Discord.
+
+    Attributes
+    ----------
+    command : arc.abc.command.CommandProto
+        The command that failed to publish.
+    """
+
+    def __init__(self, command: CommandProto, *args: t.Any) -> None:
+        self.command = command
+        super().__init__(*args)
+
+
+class GuildCommandPublishFailedError(ArcError):
+    """Raised when a set of commands could not be published to a guild.
+
+    Attributes
+    ----------
+    guild_id : hikari.Snowflake
+        The guild that commands could not be published to.
+    """
+
+    def __init__(self, guild_id: hikari.Snowflake, *args: t.Any) -> None:
+        self.guild_id = guild_id
+        super().__init__(*args)
+
+
 # MIT License
 #
 # Copyright (c) 2023-present hypergonial

arc/events.py

@@ -17,7 +17,11 @@ class ArcEvent(hikari.Event):
 
 
 class CommandErrorEvent(ArcEvent, t.Generic[GatewayClientT]):
-    """Event dispatched when a command raises an exception that is not handled by any error handlers."""
+    """Event dispatched when a command raises an exception that is not handled by any error handlers.
+
+    !!! warning
+        Creating any listeners for this event will disable the client error handler completely.
+    """
 
     def __init__(self, client: GatewayClientT, context: Context[GatewayClientT], exception: Exception) -> None:
         self._context = context

arc/internal/about.py

@@ -5,7 +5,7 @@ __author_email__: t.Final[str] = "46067571+hypergonial@users.noreply.github.com"
 __maintainer__: t.Final[str] = "hypergonial"
 __license__: t.Final[str] = "MIT"
 __url__: t.Final[str] = "https://github.com/hypergonial/hikari-arc"
-__version__: t.Final[str] = "0.5.0"
+__version__: t.Final[str] = "0.6.0"
 
 # MIT License
 #

arc/internal/options.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import typing as t
+
+import hikari
+
+from arc.abc.option import OptionType
+
+if t.TYPE_CHECKING:
+    from arc.abc.option import CommandOptionBase
+    from arc.internal.types import ClientT
+
+
+OPTIONTYPE_TO_TYPE: dict[OptionType, type[t.Any]] = {
+    OptionType.STRING: str,
+    OptionType.INTEGER: int,
+    OptionType.BOOLEAN: bool,
+    OptionType.USER: hikari.PartialUser,
+    OptionType.CHANNEL: hikari.PartialChannel,
+    OptionType.ROLE: hikari.Role,
+    OptionType.MENTIONABLE: hikari.Unique,
+    OptionType.FLOAT: float,
+    OptionType.ATTACHMENT: hikari.Attachment,
+}
+"""Used for runtime type checking in Context.get_option, not much else at the moment."""
+
+
+def resolve_snowflake_value(
+    value: hikari.Snowflake, opt_type: hikari.OptionType | int, resolved: hikari.ResolvedOptionData
+) -> t.Any:
+    """Resolve a snowflake value into a resolved option.
+
+    Parameters
+    ----------
+    value : hikari.Snowflake
+        The snowflake value to resolve.
+    opt_type : hikari.OptionType | int
+        The type of the option.
+    resolved : hikari.ResolvedOptionData
+        The resolved option data of the interaction.
+
+    Returns
+    -------
+    Any
+        The resolved snowflake value.
+
+    Raises
+    ------
+    ValueError
+        If the option type is not a valid option type.
+    """
+    match opt_type:
+        case hikari.OptionType.USER:
+            out = resolved.members.get(value) or resolved.users[value]
+        case hikari.OptionType.ATTACHMENT:
+            out = resolved.attachments[value]
+        case hikari.OptionType.CHANNEL:
+            out = resolved.channels[value]
+        case hikari.OptionType.ROLE:
+            out = resolved.roles[value]
+        case hikari.OptionType.MENTIONABLE:
+            out = resolved.members.get(value) or resolved.users.get(value) or resolved.roles[value]
+        case _:
+            raise ValueError(f"Unexpected option type '{opt_type}.'")
+
+    return out
+
+
+def resolve_options(
+    local_options: t.MutableMapping[str, CommandOptionBase[ClientT, t.Any, t.Any]],
+    incoming_options: t.Sequence[hikari.CommandInteractionOption],
+    resolved: hikari.ResolvedOptionData | None,
+) -> dict[str, t.Any]:
+    """Resolve the options into kwargs for the callback.
+
+    Parameters
+    ----------
+    local_options : t.MutableMapping[str, Option[t.Any, t.Any]]
+        The options of the locally stored command.
+    incoming_options : t.Sequence[hikari.CommandInteractionOption]
+        The options of the interaction.
+    resolved : hikari.ResolvedOptionData
+        The resolved option data of the interaction.
+
+    Returns
+    -------
+    dict[str, Any]
+        The resolved options as kwargs, ready to be passed to the callback.
+    """
+    option_kwargs: dict[str, t.Any] = {}
+
+    for arg_name, opt in local_options.items():
+        inter_opt = next((o for o in incoming_options if o.name == opt.name), None)
+
+        if inter_opt is None:
+            continue
+
+        if isinstance(inter_opt.value, hikari.Snowflake) and resolved:
+            option_kwargs[arg_name] = resolve_snowflake_value(inter_opt.value, inter_opt.type, resolved)
+
+        elif isinstance(inter_opt.value, hikari.Snowflake):
+            raise ValueError(f"Missing resolved option data for '{inter_opt.name}'.")
+        else:
+            option_kwargs[arg_name] = inter_opt.value
+
+    return option_kwargs

arc/internal/sigparse.py

@@ -41,6 +41,7 @@ TYPE_TO_OPTION_MAPPING: dict[t.Type[t.Any], t.Type[CommandOptionBase[t.Any, t.An
     int: IntOption,
     str: StrOption,
     float: FloatOption,
+    hikari.Role: RoleOption,
     hikari.User | hikari.Role: MentionableOption,
     t.Union[hikari.User, hikari.Role]: MentionableOption,
     hikari.Attachment: AttachmentOption,
@@ -51,11 +52,14 @@ TYPE_TO_OPTION_MAPPING: dict[t.Type[t.Any], t.Type[CommandOptionBase[t.Any, t.An
     hikari.GuildNewsChannel: ChannelOption,
     hikari.GuildPrivateThread: ChannelOption,
     hikari.GuildPublicThread: ChannelOption,
+    hikari.GuildNewsThread: ChannelOption,
     hikari.GuildForumChannel: ChannelOption,
+    hikari.GuildThreadChannel: ChannelOption,
     hikari.DMChannel: ChannelOption,
     hikari.GroupDMChannel: ChannelOption,
     hikari.GuildStageChannel: ChannelOption,
     hikari.PartialChannel: ChannelOption,
+    hikari.InteractionChannel: ChannelOption,
     hikari.TextableChannel: ChannelOption,
     hikari.GuildChannel: ChannelOption,
     hikari.PrivateChannel: ChannelOption,
@@ -83,6 +87,7 @@ CHANNEL_TYPES_MAPPING: dict[t.Type[hikari.PartialChannel], hikari.ChannelType |
     hikari.GuildNewsChannel: hikari.ChannelType.GUILD_NEWS,
     hikari.GuildPrivateThread: hikari.ChannelType.GUILD_PRIVATE_THREAD,
     hikari.GuildPublicThread: hikari.ChannelType.GUILD_PUBLIC_THREAD,
+    hikari.GuildNewsThread: hikari.ChannelType.GUILD_NEWS_THREAD,
     hikari.GuildForumChannel: hikari.ChannelType.GUILD_FORUM,
     hikari.DMChannel: hikari.ChannelType.DM,
     hikari.GroupDMChannel: hikari.ChannelType.GROUP_DM,
@@ -105,6 +110,19 @@ CHANNEL_TYPES_MAPPING: dict[t.Type[hikari.PartialChannel], hikari.ChannelType |
         hikari.ChannelType.GROUP_DM,
         hikari.ChannelType.GUILD_STAGE,
     },
+    hikari.InteractionChannel: {
+        hikari.ChannelType.GUILD_TEXT,
+        hikari.ChannelType.GUILD_VOICE,
+        hikari.ChannelType.GUILD_CATEGORY,
+        hikari.ChannelType.GUILD_NEWS,
+        hikari.ChannelType.GUILD_FORUM,
+        hikari.ChannelType.GUILD_NEWS_THREAD,
+        hikari.ChannelType.GUILD_PUBLIC_THREAD,
+        hikari.ChannelType.GUILD_PRIVATE_THREAD,
+        hikari.ChannelType.DM,
+        hikari.ChannelType.GROUP_DM,
+        hikari.ChannelType.GUILD_STAGE,
+    },
     hikari.TextableChannel: {
         hikari.ChannelType.GUILD_TEXT,
         hikari.ChannelType.GUILD_VOICE,
@@ -366,7 +384,7 @@ def parse_command_signature(  # noqa: C901
     return options
 
 
-def parse_event_signature(func: t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]) -> list[type[EventT]]:
+def parse_event_signature(func: t.Callable[[EventT], t.Awaitable[None]]) -> list[type[EventT]]:
     """Parse an event callback function's signature and return the event type, ignore other type hints."""
     hints = t.get_type_hints(func)
 

arc/internal/sync.py

@@ -8,6 +8,8 @@ from contextlib import suppress
 
 import hikari
 
+from arc.errors import GuildCommandPublishFailedError
+
 if t.TYPE_CHECKING:
     from arc.abc.client import Client
     from arc.abc.command import CommandBase
@@ -153,7 +155,7 @@ def _get_all_commands(
     ] = defaultdict(lambda: defaultdict(lambda: defaultdict(dict)))  # type: ignore
 
     for command in itertools.chain(
-        client.slash_commands.values(), client.message_commands.values(), client.user_commands.values()
+        client._slash_commands.values(), client._message_commands.values(), client._user_commands.values()
     ):
         if command.guilds:
             for guild_id in command.guilds:
@@ -293,7 +295,10 @@ async def _sync_commands_for_guild(
             builders.append(existing._build())
             created += 1
 
-    created = await client.app.rest.set_application_commands(client.application, builders, guild)
+    try:
+        created = await client.app.rest.set_application_commands(client.application, builders, guild)
+    except Exception as e:
+        raise GuildCommandPublishFailedError(guild_id, e, f"Failed to register commands in guild {guild_id}.") from e
 
     for existing in created:
         with suppress(KeyError):

arc/internal/types.py

@@ -24,19 +24,14 @@ EventT = t.TypeVar("EventT", bound="hikari.Event")
 BuilderT = t.TypeVar("BuilderT", bound="hikari.api.SlashCommandBuilder | hikari.api.ContextMenuCommandBuilder")
 ParamsT = t.TypeVar("ParamsT", bound="OptionParams[t.Any]")
 HookableT = t.TypeVar("HookableT", bound="Hookable[t.Any]")
-P = t.ParamSpec("P")
 
 # Type aliases
-EventCallbackT: t.TypeAlias = "t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]"
-ErrorHandlerCallbackT: t.TypeAlias = (
-    "t.Callable[t.Concatenate[Context[ClientT], Exception, ...], t.Coroutine[t.Any, t.Any, None]]"
-)
+EventCallbackT: t.TypeAlias = "t.Callable[[EventT], t.Awaitable[None]]"
+ErrorHandlerCallbackT: t.TypeAlias = "t.Callable[[Context[ClientT], Exception], t.Awaitable[None]]"
 SlashCommandLike: t.TypeAlias = "SlashCommand[ClientT] | SlashGroup[ClientT]"
 CommandCallbackT: t.TypeAlias = "t.Callable[t.Concatenate[Context[ClientT], ...], t.Awaitable[None]]"
-MessageContextCallbackT: t.TypeAlias = (
-    "t.Callable[t.Concatenate[Context[ClientT], hikari.Message, ...], t.Awaitable[None]]"
-)
-UserContextCallbackT: t.TypeAlias = "t.Callable[t.Concatenate[Context[ClientT], hikari.User, ...], t.Awaitable[None]]"
+MessageCommandCallbackT: t.TypeAlias = "t.Callable[[Context[ClientT], hikari.Message], t.Awaitable[None]]"
+UserCommandCallbackT: t.TypeAlias = "t.Callable[[Context[ClientT], hikari.User], t.Awaitable[None]]"
 AutocompleteCallbackT: t.TypeAlias = "t.Callable[[AutocompleteData[ClientT, ChoiceT]], t.Awaitable[t.Sequence[ChoiceT]]] | t.Callable[[AutocompleteData[ClientT, ChoiceT]], t.Awaitable[t.Sequence[hikari.api.AutocompleteChoiceBuilder]]]"
 ResponseBuilderT: t.TypeAlias = (
     "hikari.api.InteractionMessageBuilder | hikari.api.InteractionDeferredBuilder | hikari.api.InteractionModalBuilder"
@@ -44,9 +39,9 @@ ResponseBuilderT: t.TypeAlias = (
 HookT: t.TypeAlias = "t.Callable[[Context[ClientT]], t.Awaitable[HookResult]] | t.Callable[[Context[ClientT]], HookResult] | t.Callable[[Context[ClientT]], None] | t.Callable[[Context[ClientT]], t.Awaitable[None]]"
 PostHookT: t.TypeAlias = "t.Callable[[Context[ClientT]], None] | t.Callable[[Context[ClientT]], t.Awaitable[None]]"
 LifeCycleHookT: t.TypeAlias = "t.Callable[[ClientT], t.Awaitable[None]]"
-CommandLocaleRequestT: t.TypeAlias = "t.Callable[t.Concatenate[CommandLocaleRequest, ...], LocaleResponse]"
-OptionLocaleRequestT: t.TypeAlias = "t.Callable[t.Concatenate[OptionLocaleRequest, ...], LocaleResponse]"
-CustomLocaleRequestT: t.TypeAlias = "t.Callable[t.Concatenate[CustomLocaleRequest, ...], str]"
+CommandLocaleRequestT: t.TypeAlias = "t.Callable[[CommandLocaleRequest], LocaleResponse]"
+OptionLocaleRequestT: t.TypeAlias = "t.Callable[[OptionLocaleRequest], LocaleResponse]"
+CustomLocaleRequestT: t.TypeAlias = "t.Callable[[CustomLocaleRequest], str]"
 
 # MIT License
 #

arc/plugin.py

@@ -140,7 +140,7 @@ class GatewayPluginBase(PluginBase[GatewayClientT]):
         ----------
         event : type[hikari.Event]
             The event to subscribe to.
-        callback : Callable[[EventT], Awaitable[None]]
+        callback : t.Callable[[EventT], t.Awaitable[None]]
             The callback to call when the event is dispatched.
         """
         if event not in self.listeners:
@@ -158,7 +158,7 @@ class GatewayPluginBase(PluginBase[GatewayClientT]):
         ----------
         event : type[hikari.Event]
             The event to unsubscribe from.
-        callback : Callable[[EventT], Awaitable[None]]
+        callback : t.Callable[[EventT], t.Awaitable[None]]
             The callback to unsubscribe.
         """
         if event not in self.listeners:

arc/utils/__init__.py

@@ -1,5 +1,5 @@
 from .hooks import (
-    RateLimiter,
+    LimiterHook,
     bot_has_permissions,
     channel_limiter,
     custom_limiter,
@@ -12,6 +12,7 @@ from .hooks import (
     owner_only,
     user_limiter,
 )
+from .ratelimiter import RateLimiter, RateLimiterExhaustedError
 
 __all__ = (
     "guild_only",
@@ -25,7 +26,9 @@ __all__ = (
     "member_limiter",
     "channel_limiter",
     "custom_limiter",
+    "LimiterHook",
     "RateLimiter",
+    "RateLimiterExhaustedError",
 )
 
 # MIT License

arc/utils/hooks/__init__.py

@@ -1,6 +1,6 @@
 from .basic import bot_has_permissions, dm_only, guild_only, has_permissions, owner_only
 from .limiters import (
-    RateLimiter,
+    LimiterHook,
     channel_limiter,
     custom_limiter,
     global_limiter,
@@ -21,5 +21,5 @@ __all__ = (
     "user_limiter",
     "member_limiter",
     "custom_limiter",
-    "RateLimiter",
+    "LimiterHook",
 )