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

arc/abc/option.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import abc
+import enum
 import typing as t
 from typing import Any
 
@@ -16,7 +17,15 @@ if t.TYPE_CHECKING:
     from arc.abc.client import Client
     from arc.abc.command import CommandProto
 
-__all__ = ("Option", "OptionParams", "OptionWithChoices", "OptionWithChoicesParams", "OptionBase", "CommandOptionBase")
+__all__ = (
+    "Option",
+    "OptionParams",
+    "OptionWithChoices",
+    "OptionWithChoicesParams",
+    "OptionBase",
+    "CommandOptionBase",
+    "OptionType",
+)
 
 T = t.TypeVar("T")
 
@@ -37,6 +46,65 @@ arc.Option[int, arc.IntParams(...)]
 """
 
 
+class OptionType(enum.IntEnum):
+    """The type of a command option.
+
+    This is practically identical to `hikari.OptionType` at the moment.
+    It may however be used in the future to define custom option types.
+    """
+
+    SUB_COMMAND = 1
+    """Denotes a command option where the value will be a sub command."""
+
+    SUB_COMMAND_GROUP = 2
+    """Denotes a command option where the value will be a sub command group."""
+
+    STRING = 3
+    """Denotes a command option where the value will be a string."""
+
+    INTEGER = 4
+    """Denotes a command option where the value will be a int.
+
+    This is range limited between -2^53 and 2^53.
+    """
+
+    BOOLEAN = 5
+    """Denotes a command option where the value will be a bool."""
+
+    USER = 6
+    """Denotes a command option where the value will be resolved to a user."""
+
+    CHANNEL = 7
+    """Denotes a command option where the value will be resolved to a channel."""
+
+    ROLE = 8
+    """Denotes a command option where the value will be resolved to a role."""
+
+    MENTIONABLE = 9
+    """Denotes a command option where the value will be a snowflake ID."""
+
+    FLOAT = 10
+    """Denotes a command option where the value will be a float.
+
+    This is range limited between -2^53 and 2^53.
+    """
+
+    ATTACHMENT = 11
+    """Denotes a command option where the value will be an attachment."""
+
+    @classmethod
+    def from_hikari(cls, option_type: hikari.OptionType) -> OptionType:
+        """Convert a hikari.OptionType to an OptionType."""
+        return cls(option_type.value)
+
+    def to_hikari(self) -> hikari.OptionType:
+        """Convert an OptionType to a hikari.OptionType."""
+        # TODO: Map custom option types to their respective hikari.OptionType
+        return hikari.OptionType(self.value)
+
+    # TODO: When adding custom convertible option types, add them with an offset of 1000 or so
+
+
 class OptionParams(t.Generic[T]):
     """The base class for all option parameters objects.
 
@@ -54,9 +122,9 @@ class OptionParams(t.Generic[T]):
 
     def __init__(
         self,
-        name: str | None = None,
         description: str = "No description provided.",
         *,
+        name: str | None = None,
         name_localizations: t.Mapping[hikari.Locale, str] | None = None,
         description_localizations: t.Mapping[hikari.Locale, str] | None = None,
     ) -> None:
@@ -110,9 +178,9 @@ class OptionWithChoicesParams(OptionParams[ChoiceT], t.Generic[ChoiceT, ClientT]
 
     def __init__(
         self,
-        name: str | None = None,
         description: str = "No description provided.",
         *,
+        name: str | None = None,
         name_localizations: t.Mapping[hikari.Locale, str] | None = None,
         description_localizations: t.Mapping[hikari.Locale, str] | None = None,
         choices: t.Sequence[ChoiceT | hikari.CommandChoice] | t.Mapping[str, ChoiceT] | None = None,
@@ -153,13 +221,13 @@ class OptionBase(abc.ABC, t.Generic[T]):
 
     @property
     @abc.abstractmethod
-    def option_type(self) -> hikari.OptionType:
+    def option_type(self) -> OptionType:
         """The type of the option. Used to register the command."""
 
     def _to_dict(self) -> dict[str, t.Any]:
         """Convert the option to a dictionary of kwargs that can be passed to hikari.CommandOption."""
         return {
-            "type": self.option_type,
+            "type": self.option_type.to_hikari(),
             "name": self.name,
             "description": self.description,
             "autocomplete": False,

arc/abc/plugin.py

@@ -8,15 +8,16 @@ import typing as t
 
 import hikari
 
+from arc.abc.command import _CommandSettings
 from arc.abc.error_handler import HasErrorHandler
 from arc.abc.hookable import Hookable
 from arc.command import MessageCommand, SlashCommand, SlashGroup, UserCommand
+from arc.command.slash import SlashSubCommand, SlashSubGroup
 from arc.context import AutodeferMode, Context
 from arc.internal.types import BuilderT, ClientT, ErrorHandlerCallbackT, HookT, PostHookT, SlashCommandLike
 
 if t.TYPE_CHECKING:
     from arc.abc.command import CommandBase
-    from arc.command import SlashSubCommand, SlashSubGroup
 
 __all__ = ("PluginBase",)
 
@@ -31,17 +32,52 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT]):
     ----------
     name : str
         The name of this plugin. This must be unique across all plugins.
+    default_enabled_guilds : t.Sequence[hikari.Snowflake] | hikari.UndefinedType
+        The default guilds to enable commands in
+    autodefer : bool | AutodeferMode
+        If True, all commands in this plugin will automatically defer if it is taking longer than 2 seconds to respond.
+        This can be overridden on a per-command basis.
+    is_dm_enabled : bool | hikari.UndefinedType
+        Whether commands in this plugin are enabled in DMs
+        This can be overridden on a per-command basis.
+    default_permissions : hikari.Permissions | hikari.UndefinedType
+        The default permissions for this plugin
+        This can be overridden on a per-command basis.
+    is_nsfw : bool | hikari.UndefinedType
+        Whether this plugin is only usable in NSFW channels
+
+    !!! note
+        Parameters left as `hikari.UNDEFINED` will be inherited from the parent client.
     """
 
     def __init__(
-        self, name: str, *, default_enabled_guilds: hikari.UndefinedOr[t.Sequence[hikari.Snowflake]] = hikari.UNDEFINED
+        self,
+        name: str,
+        *,
+        default_enabled_guilds: t.Sequence[hikari.Snowflakeish | hikari.PartialGuild]
+        | hikari.UndefinedType = hikari.UNDEFINED,
+        autodefer: bool | AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED,
+        is_dm_enabled: bool | hikari.UndefinedType = hikari.UNDEFINED,
+        default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
+        is_nsfw: bool | hikari.UndefinedType = hikari.UNDEFINED,
     ) -> None:
         self._client: ClientT | None = None
         self._name = name
+        self._default_enabled_guilds = (
+            tuple(hikari.Snowflake(i) for i in default_enabled_guilds)
+            if default_enabled_guilds is not hikari.UNDEFINED
+            else hikari.UNDEFINED
+        )
+        self._cmd_settings = _CommandSettings(
+            autodefer=AutodeferMode(autodefer) if isinstance(autodefer, bool) else autodefer,
+            is_dm_enabled=is_dm_enabled,
+            default_permissions=default_permissions,
+            is_nsfw=is_nsfw,
+        )
+
         self._slash_commands: dict[str, SlashCommandLike[ClientT]] = {}
         self._user_commands: dict[str, UserCommand[ClientT]] = {}
         self._message_commands: dict[str, MessageCommand[ClientT]] = {}
-        self._default_enabled_guilds = default_enabled_guilds
         self._error_handler: ErrorHandlerCallbackT[ClientT] | None = None
         self._hooks: list[HookT[ClientT]] = []
         self._post_hooks: list[PostHookT[ClientT]] = []
@@ -86,7 +122,7 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT]):
         return self._client
 
     @property
-    def default_enabled_guilds(self) -> hikari.UndefinedOr[t.Sequence[hikari.Snowflake]]:
+    def default_enabled_guilds(self) -> t.Sequence[hikari.Snowflake] | hikari.UndefinedType:
         """The default guilds to enable commands in."""
         return self._default_enabled_guilds
 
@@ -99,6 +135,10 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT]):
         except Exception as exc:
             await self.client._on_error(ctx, exc)
 
+    def _resolve_settings(self) -> _CommandSettings:
+        settings = self._client._cmd_settings if self._client is not None else _CommandSettings.default()
+        return settings.apply(self._cmd_settings)
+
     def _resolve_hooks(self) -> list[HookT[ClientT]]:
         return self._hooks
 
@@ -183,13 +223,13 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT]):
         name: str,
         description: str = "No description provided.",
         *,
-        guilds: hikari.UndefinedOr[t.Sequence[hikari.Snowflake]] = hikari.UNDEFINED,
-        autodefer: bool | AutodeferMode = True,
-        is_dm_enabled: bool = True,
-        default_permissions: hikari.UndefinedOr[hikari.Permissions] = hikari.UNDEFINED,
-        name_localizations: dict[hikari.Locale, str] | None = None,
-        description_localizations: dict[hikari.Locale, str] | None = None,
-        is_nsfw: bool = False,
+        guilds: t.Sequence[hikari.Snowflakeish | hikari.PartialGuild] | hikari.UndefinedType = hikari.UNDEFINED,
+        autodefer: bool | AutodeferMode | hikari.UndefinedType = hikari.UNDEFINED,
+        is_dm_enabled: bool | hikari.UndefinedType = hikari.UNDEFINED,
+        is_nsfw: bool | hikari.UndefinedType = hikari.UNDEFINED,
+        default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
+        name_localizations: t.Mapping[hikari.Locale, str] | None = None,
+        description_localizations: t.Mapping[hikari.Locale, str] | None = None,
     ) -> SlashGroup[ClientT]:
         """Add a new slash command group to this client.
 
@@ -199,27 +239,30 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT]):
             The name of the slash command group.
         description : str
             The description of the slash command group.
-        guilds : hikari.UndefinedOr[t.Sequence[hikari.Snowflake]], optional
-            The guilds to register the slash command group in, by default hikari.UNDEFINED
-        autodefer : bool | AutodeferMode, optional
+        guilds : t.Sequence[hikari.Snowflake] | hikari.UndefinedType
+            The guilds to register the slash command group in
+        autodefer : bool | AutodeferMode
             If True, all commands in this group will automatically defer if it is taking longer than 2 seconds to respond.
             This can be overridden on a per-subcommand basis.
-        is_dm_enabled : bool, optional
-            Whether the slash command group is enabled in DMs, by default True
-        default_permissions : hikari.UndefinedOr[hikari.Permissions], optional
-            The default permissions for the slash command group, by default hikari.UNDEFINED
-        name_localizations : dict[hikari.Locale, str], optional
-            The name of the slash command group in different locales, by default None
-        description_localizations : dict[hikari.Locale, str], optional
-            The description of the slash command group in different locales, by default None
-        is_nsfw : bool, optional
-            Whether the slash command group is only usable in NSFW channels, by default False
+        is_dm_enabled : bool
+            Whether the slash command group is enabled in DMs
+        default_permissions : hikari.Permissions | hikari.UndefinedType
+            The default permissions for the slash command group
+        name_localizations : dict[hikari.Locale, str]
+            The name of the slash command group in different locales
+        description_localizations : dict[hikari.Locale, str]
+            The description of the slash command group in different locales
+        is_nsfw : bool
+            Whether the slash command group is only usable in NSFW channels
 
         Returns
         -------
         SlashGroup[te.Self]
             The slash command group that was created.
 
+        !!! note
+            Parameters left as `hikari.UNDEFINED` will be inherited from the parent plugin or client.
+
         Usage
         -----
         ```py
@@ -231,14 +274,13 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT]):
             await ctx.respond("Hello!")
         ```
         """
-        children: dict[str, SlashSubCommand[ClientT] | SlashSubGroup[ClientT]] = {}
+        guild_ids = tuple(hikari.Snowflake(i) for i in guilds) if guilds is not hikari.UNDEFINED else hikari.UNDEFINED
 
-        group = SlashGroup(
+        group: SlashGroup[ClientT] = SlashGroup(
             name=name,
             description=description,
-            children=children,
-            guilds=guilds,
-            autodefer=AutodeferMode(autodefer),
+            guilds=guild_ids,
+            autodefer=AutodeferMode(autodefer) if isinstance(autodefer, bool) else autodefer,
             is_dm_enabled=is_dm_enabled,
             default_permissions=default_permissions,
             name_localizations=name_localizations or {},
@@ -326,3 +368,117 @@ class PluginBase(HasErrorHandler[ClientT], Hookable[ClientT]):
             return decorator(func)
 
         return decorator
+
+    @t.overload
+    def walk_commands(
+        self, command_type: t.Literal[hikari.CommandType.USER], *, callable_only: bool = False
+    ) -> t.Iterator[UserCommand[ClientT]]:
+        ...
+
+    @t.overload
+    def walk_commands(
+        self, command_type: t.Literal[hikari.CommandType.MESSAGE], *, callable_only: bool = False
+    ) -> t.Iterator[MessageCommand[ClientT]]:
+        ...
+
+    @t.overload
+    def walk_commands(
+        self, command_type: t.Literal[hikari.CommandType.SLASH], *, callable_only: t.Literal[False]
+    ) -> t.Iterator[SlashCommand[ClientT] | SlashSubCommand[ClientT] | SlashGroup[ClientT] | SlashSubGroup[ClientT]]:
+        ...
+
+    @t.overload
+    def walk_commands(
+        self, command_type: t.Literal[hikari.CommandType.SLASH], *, callable_only: t.Literal[True]
+    ) -> t.Iterator[SlashCommand[ClientT] | SlashSubCommand[ClientT]]:
+        ...
+
+    def walk_commands(  # noqa: C901
+        self, command_type: hikari.CommandType, *, callable_only: bool = False
+    ) -> t.Iterator[t.Any]:
+        """Iterate over all commands of a certain type added to this plugin.
+
+        Parameters
+        ----------
+        command_type : hikari.CommandType
+            The type of commands to return.
+        callable_only : bool
+            Whether to only return commands that are directly callable.
+            If True, command groups and subgroups will be skipped.
+
+        Yields
+        ------
+        CommandT[ClientT]
+            The next command that matches the given criteria.
+
+        Usage
+        -----
+        ```py
+        for cmd in plugin.walk_commands(hikari.CommandType.SLASH):
+            print(cmd.name)
+        ```
+
+        !!! tip
+            To iterate over all types of commands, you may use [`itertools.chain()`][itertools.chain]:
+
+            ```py
+            import itertools
+
+            for cmd in itertools.chain(
+                plugin.walk_commands(hikari.CommandType.SLASH),
+                plugin.walk_commands(hikari.CommandType.MESSAGE),
+                plugin.walk_commands(hikari.CommandType.USER),
+            ):
+                print(cmd.name)
+            ```
+        """
+        if hikari.CommandType.SLASH is command_type:
+            for command in self._slash_commands.values():
+                if isinstance(command, SlashCommand):
+                    yield command
+                    continue
+
+                if not callable_only:
+                    yield command
+
+                for sub in command.children.values():
+                    if isinstance(sub, SlashSubCommand):
+                        yield sub
+                        continue
+
+                    if not callable_only:
+                        yield sub
+
+                    for subsub in sub.children.values():
+                        yield subsub
+
+        elif hikari.CommandType.MESSAGE is command_type:
+            for command in self._message_commands.values():
+                yield command
+
+        elif hikari.CommandType.USER is command_type:
+            for command in self._user_commands.values():
+                yield command
+
+
+# MIT License
+#
+# Copyright (c) 2023-present hypergonial
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.

arc/client.py

@@ -10,14 +10,26 @@ from arc.context import Context
 from arc.errors import NoResponseIssuedError
 from arc.events import CommandErrorEvent
 from arc.internal.sigparse import parse_event_signature
+from arc.internal.types import GatewayBotT, RESTBotT
 from arc.plugin import GatewayPluginBase, RESTPluginBase
 
 if t.TYPE_CHECKING:
     import typing_extensions as te
 
+    from arc import AutodeferMode
+
     from .internal.types import EventCallbackT, EventT, ResponseBuilderT
 
-__all__ = ("GatewayClient", "RESTClient")
+__all__ = (
+    "GatewayClientBase",
+    "RESTClientBase",
+    "GatewayClient",
+    "RESTClient",
+    "GatewayContext",
+    "RESTContext",
+    "RESTPlugin",
+    "GatewayPlugin",
+)
 
 
 T = t.TypeVar("T")
@@ -26,20 +38,33 @@ P = t.ParamSpec("P")
 logger = logging.getLogger(__name__)
 
 
-class GatewayClient(Client[hikari.GatewayBotAware]):
-    """The default implementation for an arc client with `hikari.GatewayBotAware` support.
-    If you want to use a `hikari.RESTBotAware`, use [`RESTClient`][arc.client.RESTClient] instead.
+class GatewayClientBase(Client[GatewayBotT]):
+    """The base class for an arc client with Gateway support.
+
+    If you want to use a RESTBot, use [`RESTClientBase`][arc.client.RESTClientBase] instead.
 
     Parameters
     ----------
     app : hikari.GatewayBotAware
         The application this client is for.
-    default_enabled_guilds : t.Sequence[hikari.Snowflake] | None, optional
-        The guilds that slash commands will be registered in by default, by default None
-    autosync : bool, optional
-        Whether to automatically sync commands on startup, by default True
-    provided_locales : t.Sequence[hikari.Locale] | None, optional
-        The locales that will be provided to the client by locale provider callbacks, by default None
+    default_enabled_guilds : t.Sequence[hikari.Snowflakeish] | None
+        The guilds that commands will be registered in by default
+    autosync : bool
+        Whether to automatically sync commands on startup
+    autodefer : bool | AutodeferMode
+        Whether to automatically defer responses
+        This applies to all commands, and can be overridden on a per-command basis.
+    default_permissions : hikari.Permissions | hikari.UndefinedType
+        The default permissions for commands
+        This applies to all commands, and can be overridden on a per-command basis.
+    is_nsfw : bool
+        Whether commands are NSFW
+        This applies to all commands, and can be overridden on a per-command basis.
+    is_dm_enabled : bool
+        Whether commands are enabled in DMs
+        This applies to all commands, and can be overridden on a per-command basis.
+    provided_locales : t.Sequence[hikari.Locale] | None
+        The locales that will be provided to the client by locale provider callbacks
 
     Usage
     -----
@@ -48,6 +73,7 @@ class GatewayClient(Client[hikari.GatewayBotAware]):
     import arc
 
     bot = hikari.GatewayBot("TOKEN")
+    # Default client implementation
     client = arc.GatewayClient(bot)
 
     ...
@@ -58,14 +84,26 @@ class GatewayClient(Client[hikari.GatewayBotAware]):
 
     def __init__(
         self,
-        app: hikari.GatewayBotAware,
+        app: GatewayBotT,
         *,
-        default_enabled_guilds: t.Sequence[hikari.Snowflake] | None = None,
+        default_enabled_guilds: t.Sequence[hikari.Snowflakeish | hikari.PartialGuild]
+        | hikari.UndefinedType = hikari.UNDEFINED,
         autosync: bool = True,
+        autodefer: bool | AutodeferMode = True,
+        default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
+        is_nsfw: bool = False,
+        is_dm_enabled: bool = True,
         provided_locales: t.Sequence[hikari.Locale] | None = None,
     ) -> None:
         super().__init__(
-            app, default_enabled_guilds=default_enabled_guilds, autosync=autosync, provided_locales=provided_locales
+            app,
+            default_enabled_guilds=default_enabled_guilds,
+            autosync=autosync,
+            autodefer=autodefer,
+            default_permissions=default_permissions,
+            is_nsfw=is_nsfw,
+            is_dm_enabled=is_dm_enabled,
+            provided_locales=provided_locales,
         )
         self.app.event_manager.subscribe(hikari.StartedEvent, self._on_gatewaybot_startup)
         self.app.event_manager.subscribe(hikari.StoppingEvent, self._on_gatewaybot_shutdown)
@@ -108,7 +146,7 @@ class GatewayClient(Client[hikari.GatewayBotAware]):
             The event type to subscribe to.
 
             `EventT` must be a subclass of `hikari.events.base_events.Event`.
-        callback : t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]
+        callback : t.Callable[EventT], t.Awaitable[None]]
             The callback to call when the event is dispatched.
         """
         self.app.event_manager.subscribe(event_type, callback)  # pyright: ignore reportGeneralTypeIssues
@@ -120,7 +158,7 @@ class GatewayClient(Client[hikari.GatewayBotAware]):
         ----------
         event_type : type[EventT]
             The event type to unsubscribe from.
-        callback : t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]
+        callback : t.Callable[[EventT], t.Awaitable[None]]
             The callback to unsubscribe.
         """
         self.app.event_manager.unsubscribe(event_type, callback)  # pyright: ignore reportGeneralTypeIssues
@@ -140,7 +178,7 @@ class GatewayClient(Client[hikari.GatewayBotAware]):
 
         Returns
         -------
-        t.Callable[t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]], t.Callable[t.Concatenate[EventT, ...], t.Awaitable[None]]]
+        t.Callable[t.Callable[[EventT], t.Awaitable[None]]], t.Callable[[EventT], t.Awaitable[None]]]
             A decorator for a coroutine function that passes it to
             `EventManager.subscribe` before returning the function
             reference.
@@ -157,20 +195,33 @@ class GatewayClient(Client[hikari.GatewayBotAware]):
         return decorator
 
 
-class RESTClient(Client[hikari.RESTBotAware]):
-    """The default implementation for an arc client with `hikari.RESTBotAware` support.
-    If you want to use `hikari.GatewayBotAware`, use [`GatewayClient`][arc.client.GatewayClient] instead.
+class RESTClientBase(Client[RESTBotT]):
+    """The base class for an arc client with REST support.
+
+    If you want to use GatewayBot, use [`GatewayClient`][arc.client.GatewayClientBase] instead.
 
     Parameters
     ----------
-    app : hikari.RESTBotAware
+    app : hikari.GatewayBotAware
         The application this client is for.
-    default_enabled_guilds : t.Sequence[hikari.Snowflake] | None, optional
-        The guilds that slash commands will be registered in by default, by default None
-    autosync : bool, optional
-        Whether to automatically sync commands on startup, by default True
-    provided_locales : t.Sequence[hikari.Locale] | None, optional
-        The locales that will be provided to the client by locale provider callbacks, by default None
+    default_enabled_guilds : t.Sequence[hikari.Snowflakeish | hikari.PartialGuild] | None
+        The guilds that commands will be registered in by default
+    autosync : bool
+        Whether to automatically sync commands on startup
+    autodefer : bool | AutodeferMode
+        Whether to automatically defer responses
+        This applies to all commands, and can be overridden on a per-command basis.
+    default_permissions : hikari.Permissions | hikari.UndefinedType
+        The default permissions for commands
+        This applies to all commands, and can be overridden on a per-command basis.
+    is_nsfw : bool
+        Whether commands are NSFW
+        This applies to all commands, and can be overridden on a per-command basis.
+    is_dm_enabled : bool
+        Whether commands are enabled in DMs
+        This applies to all commands, and can be overridden on a per-command basis.
+    provided_locales : t.Sequence[hikari.Locale] | None
+        The locales that will be provided to the client by locale provider callbacks
 
 
     Usage
@@ -180,6 +231,7 @@ class RESTClient(Client[hikari.RESTBotAware]):
     import arc
 
     bot = hikari.RESTBot("TOKEN")
+    # Default client implementation
     client = arc.RESTClient(bot)
 
     ...
@@ -193,14 +245,26 @@ class RESTClient(Client[hikari.RESTBotAware]):
 
     def __init__(
         self,
-        app: hikari.RESTBotAware,
+        app: RESTBotT,
         *,
-        default_enabled_guilds: t.Sequence[hikari.Snowflake] | None = None,
+        default_enabled_guilds: t.Sequence[hikari.Snowflakeish | hikari.PartialGuild]
+        | hikari.UndefinedType = hikari.UNDEFINED,
         autosync: bool = True,
+        autodefer: bool | AutodeferMode = True,
+        default_permissions: hikari.Permissions | hikari.UndefinedType = hikari.UNDEFINED,
+        is_nsfw: bool = False,
+        is_dm_enabled: bool = True,
         provided_locales: t.Sequence[hikari.Locale] | None = None,
     ) -> None:
         super().__init__(
-            app, default_enabled_guilds=default_enabled_guilds, autosync=autosync, provided_locales=provided_locales
+            app,
+            default_enabled_guilds=default_enabled_guilds,
+            autosync=autosync,
+            autodefer=autodefer,
+            default_permissions=default_permissions,
+            is_nsfw=is_nsfw,
+            is_dm_enabled=is_dm_enabled,
+            provided_locales=provided_locales,
         )
         self.app.add_startup_callback(self._on_restbot_startup)
         self.app.add_shutdown_callback(self._on_restbot_shutdown)
@@ -261,16 +325,22 @@ class RESTClient(Client[hikari.RESTBotAware]):
         return builder
 
 
-GatewayContext = Context[GatewayClient]
+GatewayClient = GatewayClientBase[hikari.GatewayBotAware]
+"""The default gateway client implementation. An alias for [`arc.GatewayClientBase[hikari.GatewayBotAware]`][arc.client.GatewayClientBase]."""
+
+RESTClient = RESTClientBase[hikari.RESTBotAware]
+"""The default REST client implementation. An alias for [`arc.RESTClientBase[hikari.RESTBotAware]`][arc.client.RESTClientBase]."""
+
+GatewayContext = Context[GatewayClientBase[hikari.GatewayBotAware]]
 """A context using the default gateway client implementation. An alias for [`arc.Context[arc.GatewayClient]`][arc.context.base.Context]."""
 
-RESTContext = Context[RESTClient]
+RESTContext = Context[RESTClientBase[hikari.RESTBotAware]]
 """A context using the default REST client implementation. An alias for [`arc.Context[arc.RESTClient]`][arc.context.base.Context]."""
 
-RESTPlugin = RESTPluginBase[RESTClient]
+RESTPlugin = RESTPluginBase[RESTClientBase[hikari.RESTBotAware]]
 """A plugin using the default REST client implementation. An alias for [`arc.RESTPluginBase[arc.RESTClient]`][arc.plugin.RESTPluginBase]."""
 
-GatewayPlugin = GatewayPluginBase[GatewayClient]
+GatewayPlugin = GatewayPluginBase[GatewayClientBase[hikari.GatewayBotAware]]
 """An alias for [`arc.GatewayPluginBase[arc.GatewayClient]`][arc.plugin.GatewayPluginBase]."""
 
 # MIT License