diff --git a/CHANGELOG.md b/CHANGELOG.md
index dc116e27e..3c43b5c97 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -37,8 +37,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
   `error` callback can now also be [None][] when it's unknown.
 
 ### Deprecated
-- [AbstractCooldownManager.check_cooldown][tanjun.dependencies.limiters.AbstractCooldownManager.check_cooldown] and
-  [AbstractCooldownManager.increment_cooldown][tanjun.dependencies.limiters.AbstractCooldownManager.increment_cooldown]
+- `AbstractCooldownManager.check_cooldown` and `AbstractCooldownManager.increment_cooldown`
   in favour of the [AbstractCooldownManager.acquire][tanjun.dependencies.limiters.AbstractCooldownManager.acquire]
   and [AbstractCooldownManager.release][tanjun.dependencies.limiters.AbstractCooldownManager.release] interfaces.
 
diff --git a/docs/reference/utilities.md b/docs/reference/utilities.md
deleted file mode 100644
index 67d97a2bb..000000000
--- a/docs/reference/utilities.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# tanjun.utilities
-
-`tanjun.utilities` has been deprecated in favour of [tanjun.permissions][].
diff --git a/tanjun/__init__.py b/tanjun/__init__.py
index fa570ead5..8a64a4183 100644
--- a/tanjun/__init__.py
+++ b/tanjun/__init__.py
@@ -139,7 +139,6 @@ async def hello(ctx: tanjun.abc.Context, user: hikari.User | None) -> None:
     "as_message_command",
     "as_message_command_group",
     "as_message_menu",
-    "as_self_injecting",
     "as_slash_command",
     "as_time_schedule",
     "as_unloader",
@@ -157,7 +156,6 @@ async def hello(ctx: tanjun.abc.Context, user: hikari.User | None) -> None:
     "inject",
     "inject_lc",
     "injected",
-    "injecting",
     "parsing",
     "permissions",
     "schedules",
@@ -178,7 +176,6 @@ async def hello(ctx: tanjun.abc.Context, user: hikari.User | None) -> None:
     "to_snowflake",
     "to_user",
     "to_voice_state",
-    "utilities",
     "with_all_checks",
     "with_any_checks",
     "with_argument",
@@ -216,7 +213,6 @@ async def hello(ctx: tanjun.abc.Context, user: hikari.User | None) -> None:
 from . import annotations
 from . import context
 from . import permissions
-from . import utilities
 from .abc import ClientCallbackNames
 from .checks import with_all_checks
 from .checks import with_any_checks
@@ -300,7 +296,6 @@ async def hello(ctx: tanjun.abc.Context, user: hikari.User | None) -> None:
 from .hooks import MenuHooks
 from .hooks import MessageHooks
 from .hooks import SlashHooks
-from .injecting import as_self_injecting
 from .parsing import ShlexParser
 from .parsing import with_argument
 from .parsing import with_greedy_argument
diff --git a/tanjun/abc.py b/tanjun/abc.py
index c49e2e369..1b46a2a31 100644
--- a/tanjun/abc.py
+++ b/tanjun/abc.py
@@ -36,7 +36,6 @@
     "AnyHooks",
     "AppCommand",
     "AppCommandContext",
-    "AutocompleteCallbackSig",
     "AutocompleteContext",
     "AutocompleteSig",
     "BaseSlashCommand",
@@ -44,7 +43,6 @@
     "Client",
     "ClientCallbackNames",
     "ClientLoader",
-    "CommandCallbackSig",
     "Component",
     "Context",
     "ErrorHookSig",
@@ -54,7 +52,6 @@
     "ListenerCallbackSig",
     "MenuCallbackSig",
     "MenuCommand",
-    "MenuCommandCallbackSig",
     "MenuContext",
     "MenuHooks",
     "MessageCommand",
@@ -120,9 +117,6 @@
 )
 _MenuValueT = typing.TypeVar("_MenuValueT", hikari.Message, hikari.InteractionMember)
 
-CommandCallbackSig = collections.Callable[..., _CoroT[None]]
-"""Deprecated type hint used to represent any command callback."""
-
 MetaEventSig = collections.Callable[..., typing.Union[_CoroT[None], None]]
 """Type hint of a client callback.
 
@@ -272,13 +266,6 @@
     _EventT = typing.TypeVar("_EventT", bound=hikari.Event)
     ListenerCallbackSig = types.GenericAlias(collections.Callable[..., typing.Any], (_EventT,))
 
-
-AutocompleteCallbackSig = AutocompleteSig[_AutocompleteValueT]
-"""Deprecated alias of [AutocompleteSig][tanjun.abc.AutocompleteSig]."""
-
-MenuCommandCallbackSig = MenuCallbackSig[_MenuValueT]
-"""Deprecated alias of [MenuCallbackSig][tanjun.abc.MenuCallbackSig]."""
-
 _MenuCallbackSigT = typing.TypeVar("_MenuCallbackSigT", bound=MenuCallbackSig[typing.Any])
 _MessageCallbackSigT = typing.TypeVar("_MessageCallbackSigT", bound=MessageCallbackSig)
 _SlashCallbackSigT = typing.TypeVar("_SlashCallbackSigT", bound=SlashCallbackSig)
diff --git a/tanjun/annotations.py b/tanjun/annotations.py
index b5e4c773c..8c6c94301 100644
--- a/tanjun/annotations.py
+++ b/tanjun/annotations.py
@@ -251,7 +251,6 @@ async def command(
 import itertools
 import operator
 import typing
-import warnings
 from collections import abc as collections
 
 import hikari
@@ -1422,68 +1421,7 @@ async def command(
     )
 
 
-class _FloatEnumConverter(_ConfigIdentifier):
-    """Specialised converters for float enum choices."""
-
-    __slots__ = ("_enum",)
-
-    def __init__(self, enum: collections.Callable[[float], typing.Any]) -> None:
-        self._enum = enum
-
-    def set_config(self, config: _ArgConfig, /) -> None:
-        config.float_converter = self._enum
-
-
-class _IntEnumConverter(_ConfigIdentifier):
-    """Specialised converters for int enum choices."""
-
-    __slots__ = ("_enum",)
-
-    def __init__(self, enum: collections.Callable[[int], typing.Any]) -> None:
-        self._enum = enum
-
-    def set_config(self, config: _ArgConfig, /) -> None:
-        config.int_converter = self._enum
-
-
-class _EnumConverter(_ConfigIdentifier):
-    __slots__ = ("_converter",)
-
-    def __init__(self, enum: collections.Callable[[str], enum.Enum], /) -> None:
-        self._converter = enum
-
-    def set_config(self, config: _ArgConfig, /) -> None:
-        config.str_converters = [self._converter]
-
-
-class _ChoicesMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Choices(...) to Annotated")
-    def __getitem__(cls, enum_: type[_EnumT], /) -> type[_EnumT]:
-        if issubclass(enum_, float):
-            type_ = float
-            choices = Choices(enum_.__members__)
-            converter = _FloatEnumConverter(enum_)
-
-        elif issubclass(enum_, int):
-            type_ = int
-            choices = Choices(enum_.__members__)
-            converter = _IntEnumConverter(enum_)
-
-        elif issubclass(enum_, str):
-            type_ = str
-            choices = Choices(enum_.__members__)
-            converter = None
-
-        else:
-            raise TypeError("Enum must be a subclass of str, float or int")
-
-        # TODO: do we want to wrap the convert callback to give better failed parse messages?
-        return typing.cast(
-            "type[_EnumT]", typing.Annotated[enum_, choices, converter, _EnumConverter(enum_), _OptionMarker(type_)]
-        )
-
-
-class Choices(_ConfigIdentifier, metaclass=_ChoicesMeta):
+class Choices(_ConfigIdentifier):
     """Assign up to 25 choices for a slash command option.
 
     !!! warning
@@ -1542,16 +1480,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
         config.choices = self._choices
 
 
-class _ConvertedMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Converted(...) to Annotated")
-    def __getitem__(cls, converters: typing.Union[_ConverterSig[_T], tuple[_ConverterSig[_T]]], /) -> type[_T]:
-        if not isinstance(converters, tuple):
-            converters = (converters,)
-
-        return typing.cast("type[_T]", typing.Annotated[typing.Any, Converted(*converters)])
-
-
-class Converted(_ConfigIdentifier, metaclass=_ConvertedMeta):
+class Converted(_ConfigIdentifier):
     """Marked an argument as type [Str][tanjun.annotations.Str] with converters.
 
     Examples
@@ -1610,18 +1539,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
 """An argument which takes a snowflake."""
 
 
-class _DefaultMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Default(...) to Annotated")
-    def __getitem__(cls, value: typing.Union[type[_T], tuple[type[_T], _T]], /) -> type[_T]:
-        if isinstance(value, tuple):
-            type_ = value[0]
-            return typing.cast("type[_T]", typing.Annotated[type_, Default(value[1])])
-
-        type_ = typing.cast("type[_T]", value)
-        return typing.cast("type[_T]", typing.Annotated[type_, Default()])
-
-
-class Default(_ConfigIdentifier, metaclass=_DefaultMeta):
+class Default(_ConfigIdentifier):
     """Explicitly configure an argument's default.
 
     Examples
@@ -1697,31 +1615,10 @@ async def command(
     ```
     """
 
-    __slots__ = ("_aliases", "_default", "_empty_value")
+    __slots__ = ("_aliases", "_empty_value")
 
-    @typing.overload
     def __init__(
         self, *, aliases: typing.Optional[collections.Sequence[str]] = None, empty_value: typing.Any = tanjun.NO_DEFAULT
-    ) -> None:
-        ...
-
-    @typing_extensions.deprecated("Use annotations.Default instead of the default arg")
-    @typing.overload
-    def __init__(
-        self,
-        *,
-        aliases: typing.Optional[collections.Sequence[str]] = None,
-        default: typing.Any = tanjun.NO_DEFAULT,
-        empty_value: typing.Any = tanjun.NO_DEFAULT,
-    ) -> None:
-        ...
-
-    def __init__(
-        self,
-        *,
-        aliases: typing.Optional[collections.Sequence[str]] = None,
-        default: typing.Any = tanjun.NO_DEFAULT,
-        empty_value: typing.Any = tanjun.NO_DEFAULT,
     ) -> None:
         """Create a flag instance.
 
@@ -1739,13 +1636,7 @@ def __init__(
 
             [tanjun.abc.NO_PASS][] is not supported for this.
         """
-        if default is not tanjun.NO_DEFAULT:
-            warnings.warn(
-                "Flag.__init__'s `default` argument is deprecated, use Default instead", category=DeprecationWarning
-            )
-
         self._aliases = aliases
-        self._default = default
         self._empty_value = empty_value
 
     @property
@@ -1756,16 +1647,6 @@ def aliases(self) -> typing.Optional[collections.Sequence[str]]:
         """
         return self._aliases
 
-    @property
-    @typing_extensions.deprecated("Use annotations.Default instead of the default arg")
-    def default(self) -> typing.Any:
-        """The flag's default.
-
-        If not specified then the default in the signature for this argument
-        will be used.
-        """
-        return self._default
-
     @property
     def empty_value(self) -> typing.Any:
         """The value to pass for the argument if the flag is provided without a value.
@@ -1776,9 +1657,6 @@ def empty_value(self) -> typing.Any:
         return self._empty_value
 
     def set_config(self, config: _ArgConfig, /) -> None:
-        if self._default is not tanjun.NO_DEFAULT:
-            config.default = self._default
-
         if self._aliases:
             config.message_names = [config.main_message_name, *self._aliases]
 
@@ -1786,13 +1664,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
         config.is_positional = False
 
 
-class _PositionalMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Positional(...) to Annotated")
-    def __getitem__(cls, type_: type[_T], /) -> type[_T]:
-        return typing.cast("type[_T]", typing.Annotated[type_, Positional()])
-
-
-class Positional(_ConfigIdentifier, metaclass=_PositionalMeta):
+class Positional(_ConfigIdentifier):
     """Mark an argument as being passed positionally for message command parsing.
 
     Arguments will be positional by default (unless it has a default) and this
@@ -1819,13 +1691,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
         config.is_positional = True
 
 
-class _GreedyMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Greedy(...) to Annotated")
-    def __getitem__(cls, type_: type[_T], /) -> type[_T]:
-        return typing.cast("type[_T]", typing.Annotated[type_, Greedy()])
-
-
-class Greedy(_ConfigIdentifier, metaclass=_GreedyMeta):
+class Greedy(_ConfigIdentifier):
     """Mark an argument as "greedy" for message command parsing.
 
     This means that it'll consume the rest of the positional arguments,
@@ -1852,19 +1718,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
         config.is_greedy = True
 
 
-class _LengthMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Length(...) to Annotated")
-    def __getitem__(cls, value: typing.Union[int, tuple[int, int]], /) -> type[str]:
-        if isinstance(value, int):
-            obj = Length(value)
-
-        else:
-            obj = Length(*value)
-
-        return typing.cast("type[str]", typing.Annotated[Str, obj])
-
-
-class Length(_ConfigIdentifier, metaclass=_LengthMeta):
+class Length(_ConfigIdentifier):
     """Define length restraints for a string option.
 
     !!! note
@@ -1951,16 +1805,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
         # TODO: validate this is only set for str options
 
 
-class _MaxMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Max(...) to Annotated")
-    def __getitem__(cls, value: _NumberT, /) -> type[_NumberT]:
-        if isinstance(value, int):
-            return typing.cast("type[_NumberT]", typing.Annotated[Int, Max(value)])
-
-        return typing.cast("type[_NumberT]", typing.Annotated[Float, Max(value)])
-
-
-class Max(_ConfigIdentifier, metaclass=_MaxMeta):
+class Max(_ConfigIdentifier):
     """Inclusive maximum value for a [Float][tanjun.annotations.Float] or [Int][tanjun.annotations.Int] argument.
 
     Examples
@@ -1998,16 +1843,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
         config.max_value = self._value
 
 
-class _MinMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Min(...) to Annotated")
-    def __getitem__(cls, value: _NumberT, /) -> type[_NumberT]:
-        if isinstance(value, int):
-            return typing.cast("type[_NumberT]", typing.Annotated[Int, Min(value)])
-
-        return typing.cast("type[_NumberT]", typing.Annotated[Float, Min(value)])
-
-
-class Min(_ConfigIdentifier, metaclass=_MinMeta):
+class Min(_ConfigIdentifier):
     """Inclusive minimum value for a [Float][tanjun.annotations.Float] or [Int][tanjun.annotations.Int] argument.
 
     Examples
@@ -2117,18 +1953,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
             config.message_names = [self._message_name, *config.message_names[1:]]
 
 
-class _RangedMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass Ranged(...) to Annotated")
-    def __getitem__(cls, range_: tuple[_NumberT, _NumberT], /) -> type[_NumberT]:
-        # This better matches how type checking (well pyright at least) will
-        # prefer to go to float if either value is float.
-        if isinstance(range_[0], float) or isinstance(range_[1], float):
-            return typing.cast("type[_NumberT]", typing.Annotated[Float, Ranged(range_[0], range_[1])])
-
-        return typing.cast("type[_NumberT]", typing.Annotated[Int, Ranged(range_[0], range_[1])])
-
-
-class Ranged(_ConfigIdentifier, metaclass=_RangedMeta):
+class Ranged(_ConfigIdentifier):
     """Declare the range limit for an `Int` or `Float` argument.
 
     Examples
@@ -2192,42 +2017,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
         config.min_value = self._min_value
 
 
-# _MESSAGE_ID_ONLY
-_SNOWFLAKE_PARSERS: dict[type[typing.Any], collections.Callable[[str], hikari.Snowflake]] = {
-    hikari.Member: conversion.parse_user_id,
-    hikari.PartialChannel: conversion.parse_channel_id,
-    hikari.User: conversion.parse_user_id,
-    hikari.Role: conversion.parse_role_id,
-}
-
-
-class _SnowflakeOrMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass SnowflakeOr(...) to Annotated")
-    def __getitem__(cls, type_: type[_T], /) -> type[typing.Union[hikari.Snowflake, _T]]:
-        for entry in _snoop_annotation_args(type_):
-            if not isinstance(entry, _OptionMarker):
-                continue
-
-            try:
-                parser = _SNOWFLAKE_PARSERS[entry.type]
-
-            except (KeyError, TypeError):  # Also catch unhashable
-                pass
-
-            else:
-                descriptor = SnowflakeOr(parse_id=parser)
-                break
-
-        else:
-            descriptor = SnowflakeOr()
-
-        return typing.cast(
-            "type[typing.Union[hikari.Snowflake, _T]]",
-            typing.Annotated[typing.Union[hikari.Snowflake, type_], descriptor],
-        )
-
-
-class SnowflakeOr(_ConfigIdentifier, metaclass=_SnowflakeOrMeta):
+class SnowflakeOr(_ConfigIdentifier):
     """Mark an argument as taking an object or its ID.
 
     This allows for the argument to be declared as taking the object for slash
@@ -2278,18 +2068,7 @@ def set_config(self, config: _ArgConfig, /) -> None:
         config.snowflake_converter = self._parse_id
 
 
-class _TheseChannelsMeta(abc.ABCMeta):
-    @typing_extensions.deprecated("Pass TheseChannels(...) to Annotated")
-    def __getitem__(
-        cls, value: typing.Union[_ChannelTypeIsh, collections.Collection[_ChannelTypeIsh]], /
-    ) -> type[hikari.PartialChannel]:
-        if not isinstance(value, collections.Collection):
-            value = (value,)
-
-        return typing.cast("type[hikari.PartialChannel]", typing.Annotated[Channel, TheseChannels(*value)])
-
-
-class TheseChannels(_ConfigIdentifier, metaclass=_TheseChannelsMeta):
+class TheseChannels(_ConfigIdentifier):
     """Restrain the type of channels a channel argument can target."""
 
     __slots__ = ("_channel_types",)
diff --git a/tanjun/clients.py b/tanjun/clients.py
index 543ef5ee0..e8bbcee4b 100644
--- a/tanjun/clients.py
+++ b/tanjun/clients.py
@@ -54,7 +54,6 @@
 import logging
 import pathlib
 import typing
-import warnings
 from collections import abc as collections
 
 import alluka
@@ -581,53 +580,6 @@ class Client(tanjun.Client):
         "_voice",
     )
 
-    @typing.overload
-    def __init__(
-        self,
-        rest: hikari.api.RESTClient,
-        *,
-        cache: typing.Optional[hikari.api.Cache] = None,
-        events: typing.Optional[hikari.api.EventManager] = None,
-        server: typing.Optional[hikari.api.InteractionServer] = None,
-        shards: typing.Optional[hikari.ShardAware] = None,
-        voice: typing.Optional[hikari.api.VoiceComponent] = None,
-        event_managed: bool = False,
-        injector: typing.Optional[alluka.abc.Client] = None,
-        mention_prefix: bool = False,
-        declare_global_commands: typing.Union[
-            hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
-        ] = False,
-        command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-    ) -> None:
-        ...
-
-    @typing.overload
-    @typing_extensions.deprecated("Use the declare_global_commands arg instead")
-    def __init__(
-        self,
-        rest: hikari.api.RESTClient,
-        *,
-        cache: typing.Optional[hikari.api.Cache] = None,
-        events: typing.Optional[hikari.api.EventManager] = None,
-        server: typing.Optional[hikari.api.InteractionServer] = None,
-        shards: typing.Optional[hikari.ShardAware] = None,
-        voice: typing.Optional[hikari.api.VoiceComponent] = None,
-        event_managed: bool = False,
-        injector: typing.Optional[alluka.abc.Client] = None,
-        mention_prefix: bool = False,
-        set_global_commands: typing.Union[hikari.SnowflakeishOr[hikari.PartialGuild], bool] = False,
-        declare_global_commands: typing.Union[
-            hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
-        ] = False,
-        command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        _stack_level: int = 0,
-    ) -> None:
-        ...
-
     def __init__(
         self,
         rest: hikari.api.RESTClient,
@@ -640,14 +592,12 @@ def __init__(
         event_managed: bool = False,
         injector: typing.Optional[alluka.abc.Client] = None,
         mention_prefix: bool = False,
-        set_global_commands: typing.Union[hikari.SnowflakeishOr[hikari.PartialGuild], bool] = False,
         declare_global_commands: typing.Union[
             hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
         ] = False,
         command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
         message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
         user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        _stack_level: int = 0,
     ) -> None:
         """Initialise a Tanjun client.
 
@@ -818,12 +768,7 @@ def __init__(
 
         dependencies.set_standard_dependencies(self)
         self._schedule_startup_registers(
-            set_global_commands,
-            declare_global_commands,
-            command_ids,
-            message_ids=message_ids,
-            user_ids=user_ids,
-            _stack_level=_stack_level,
+            declare_global_commands, command_ids, message_ids=message_ids, user_ids=user_ids
         )
 
     def _maybe_set_type_dep(self, type_: type[_T], value: typing.Optional[_T], /) -> Self:
@@ -834,24 +779,13 @@ def _maybe_set_type_dep(self, type_: type[_T], value: typing.Optional[_T], /) ->
 
     def _schedule_startup_registers(
         self,
-        set_global_commands: typing.Union[hikari.SnowflakeishOr[hikari.PartialGuild], bool] = False,
         declare_global_commands: typing.Union[
             hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
         ] = False,
         command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
         message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
         user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        _stack_level: int = 0,
     ) -> None:
-        if set_global_commands:
-            warnings.warn(
-                "The `set_global_commands` argument is deprecated since v2.1.1a1. "
-                "Use `declare_global_commands` instead.",
-                DeprecationWarning,
-                stacklevel=3 + _stack_level,
-            )
-
-        declare_global_commands = declare_global_commands or set_global_commands
         if isinstance(declare_global_commands, collections.Sequence):
             if command_ids and len(declare_global_commands) > 1:
                 raise ValueError(
@@ -902,27 +836,6 @@ def _add_task(self, task: asyncio.Task[typing.Any], /) -> None:
             task.add_done_callback(self._remove_task)
 
     @classmethod
-    @typing.overload
-    def from_gateway_bot(
-        cls,
-        bot: _GatewayBotProto,
-        /,
-        *,
-        event_managed: bool = True,
-        injector: typing.Optional[alluka.abc.Client] = None,
-        mention_prefix: bool = False,
-        declare_global_commands: typing.Union[
-            hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
-        ] = False,
-        command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-    ) -> Client:
-        ...
-
-    @classmethod
-    @typing.overload
-    @typing_extensions.deprecated("Use the declare_global_commands arg instead")
     def from_gateway_bot(
         cls,
         bot: _GatewayBotProto,
@@ -934,26 +847,6 @@ def from_gateway_bot(
         declare_global_commands: typing.Union[
             hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
         ] = False,
-        set_global_commands: typing.Union[hikari.SnowflakeishOr[hikari.PartialGuild], bool] = False,
-        command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-    ) -> Client:
-        ...
-
-    @classmethod
-    def from_gateway_bot(
-        cls,
-        bot: _GatewayBotProto,
-        /,
-        *,
-        event_managed: bool = True,
-        injector: typing.Optional[alluka.abc.Client] = None,
-        mention_prefix: bool = False,
-        declare_global_commands: typing.Union[
-            hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
-        ] = False,
-        set_global_commands: typing.Union[hikari.SnowflakeishOr[hikari.PartialGuild], bool] = False,
         command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
         message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
         user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
@@ -1023,37 +916,15 @@ def from_gateway_bot(
                 injector=injector,
                 mention_prefix=mention_prefix,
                 declare_global_commands=declare_global_commands,
-                set_global_commands=set_global_commands,
                 command_ids=command_ids,
                 message_ids=message_ids,
                 user_ids=user_ids,
-                _stack_level=1,
             )
             .set_human_only()
             .set_hikari_trait_injectors(bot)
         )
 
     @classmethod
-    @typing.overload
-    def from_rest_bot(
-        cls,
-        bot: hikari.RESTBotAware,
-        /,
-        *,
-        bot_managed: bool = False,
-        declare_global_commands: typing.Union[
-            hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
-        ] = False,
-        injector: typing.Optional[alluka.abc.Client] = None,
-        command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-    ) -> Client:
-        ...
-
-    @classmethod
-    @typing.overload
-    @typing_extensions.deprecated("Use the declare_global_commands arg instead")
     def from_rest_bot(
         cls,
         bot: hikari.RESTBotAware,
@@ -1064,25 +935,6 @@ def from_rest_bot(
             hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
         ] = False,
         injector: typing.Optional[alluka.abc.Client] = None,
-        set_global_commands: typing.Union[hikari.SnowflakeishOr[hikari.PartialGuild], bool] = False,
-        command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-        user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
-    ) -> Client:
-        ...
-
-    @classmethod
-    def from_rest_bot(
-        cls,
-        bot: hikari.RESTBotAware,
-        /,
-        *,
-        bot_managed: bool = False,
-        declare_global_commands: typing.Union[
-            hikari.SnowflakeishSequence[hikari.PartialGuild], hikari.SnowflakeishOr[hikari.PartialGuild], bool
-        ] = False,
-        injector: typing.Optional[alluka.abc.Client] = None,
-        set_global_commands: typing.Union[hikari.SnowflakeishOr[hikari.PartialGuild], bool] = False,
         command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
         message_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
         user_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
@@ -1144,11 +996,9 @@ def from_rest_bot(
             server=bot.interaction_server,
             declare_global_commands=declare_global_commands,
             injector=injector,
-            set_global_commands=set_global_commands,
             command_ids=command_ids,
             message_ids=message_ids,
             user_ids=user_ids,
-            _stack_level=1,
         ).set_hikari_trait_injectors(bot)
 
         if bot_managed:
@@ -1342,22 +1192,6 @@ async def clear_application_commands(
 
         await self._rest.set_application_commands(application, (), guild=guild)
 
-    @typing_extensions.deprecated("Use declare_global_commands instead")
-    async def set_global_commands(
-        self,
-        *,
-        application: typing.Optional[hikari.SnowflakeishOr[hikari.PartialApplication]] = None,
-        guild: hikari.UndefinedOr[hikari.SnowflakeishOr[hikari.PartialGuild]] = hikari.UNDEFINED,
-        force: bool = False,
-    ) -> collections.Sequence[hikari.PartialCommand]:
-        """Alias of [Client.declare_global_commands][tanjun.abc.Client.declare_global_commands].
-
-        !!! warning "deprecated"
-            Since v2.1.1a1; use [Client.declare_global_commands][tanjun.abc.Client.declare_global_commands]
-            instead.
-        """
-        return await self.declare_global_commands(application=application, guild=guild, force=force)
-
     async def declare_global_commands(
         self,
         command_ids: typing.Optional[collections.Mapping[str, hikari.SnowflakeishOr[hikari.PartialCommand]]] = None,
diff --git a/tanjun/commands/slash.py b/tanjun/commands/slash.py
index c4c0cefd2..0050ca379 100644
--- a/tanjun/commands/slash.py
+++ b/tanjun/commands/slash.py
@@ -53,7 +53,6 @@
 import copy
 import typing
 import unicodedata
-import warnings
 from collections import abc as collections
 
 import hikari
@@ -391,10 +390,6 @@ def decorator(callback: _CallbackishT[_SlashCallbackSigT], /) -> SlashCommand[_S
     return decorator
 
 
-UNDEFINED_DEFAULT = tanjun.NO_DEFAULT
-"""Deprecated alias for `tanjun.abc.NO_DEFAULT`."""
-
-
 def with_attachment_slash_option(
     name: typing.Union[str, collections.Mapping[str, str]],
     description: typing.Union[str, collections.Mapping[str, str]],
@@ -474,7 +469,6 @@ async def command(self, ctx: tanjun.abc.SlashContext, name: str) -> None:
         min_length=min_length,
         max_length=max_length,
         pass_as_kwarg=pass_as_kwarg,
-        _stack_level=1,
     )
 
 
@@ -522,7 +516,6 @@ async def command(self, ctx: tanjun.abc.SlashContext, int_value: int) -> None:
         min_value=min_value,
         max_value=max_value,
         pass_as_kwarg=pass_as_kwarg,
-        _stack_level=1,
     )
 
 
@@ -572,7 +565,6 @@ async def command(self, ctx: tanjun.abc.SlashContext, float_value: float) -> Non
         min_value=min_value,
         max_value=max_value,
         pass_as_kwarg=pass_as_kwarg,
-        _stack_level=1,
     )
 
 
@@ -1690,10 +1682,7 @@ def _add_option(
         autocomplete: bool = False,
         channel_types: typing.Optional[collections.Sequence[int]] = None,
         choices: typing.Union[
-            collections.Mapping[str, typing.Union[str, int, float]],
-            collections.Sequence[tuple[str, typing.Union[str, int, float]]],
-            collections.Sequence[hikari.CommandChoice],
-            None,
+            collections.Mapping[str, typing.Union[str, int, float]], collections.Sequence[hikari.CommandChoice], None
         ] = None,
         converters: typing.Union[collections.Sequence[_AnyConverterSig], _AnyConverterSig] = (),
         default: typing.Any = tanjun.NO_DEFAULT,
@@ -1704,7 +1693,6 @@ def _add_option(
         max_value: typing.Union[int, float, None] = None,
         only_member: bool = False,
         pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
     ) -> Self:
         names.assert_length(1, 32).assert_matches(_SCOMMAND_NAME_REG, _validate_name, lower_only=True)
         descriptions.assert_length(1, 100)
@@ -1746,23 +1734,7 @@ def _add_option(
             actual_choices = [hikari.CommandChoice(name=name, value=value) for name, value in choices.items()]
 
         else:
-            actual_choices = []
-            warned = False
-            for choice in choices:
-                if isinstance(choice, tuple):
-                    if not warned:
-                        warned = True
-                        warnings.warn(
-                            "Passing a sequence of tuples to `choices` is deprecated since 2.1.2a1, "
-                            "please pass a mapping instead.",
-                            category=DeprecationWarning,
-                            stacklevel=2 + _stack_level,
-                        )
-
-                    actual_choices.append(hikari.CommandChoice(name=choice[0], value=choice[1]))
-
-                else:
-                    actual_choices.append(choice)
+            actual_choices = list(choices)
 
         if actual_choices and len(actual_choices) > 25:
             raise ValueError("Slash command options cannot have more than 25 choices")
@@ -1869,7 +1841,6 @@ def add_attachment_option(
             pass_as_kwarg=pass_as_kwarg,
         )
 
-    @typing.overload
     def add_str_option(
         self,
         name: typing.Union[str, collections.Mapping[str, str]],
@@ -1886,51 +1857,6 @@ def add_str_option(
         min_length: typing.Optional[int] = None,
         max_length: typing.Optional[int] = None,
         pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
-    ) -> Self:
-        ...
-
-    @typing.overload
-    @typing_extensions.deprecated("Pass a dict for `choices`, not a sequence of tuples")
-    def add_str_option(
-        self,
-        name: typing.Union[str, collections.Mapping[str, str]],
-        description: typing.Union[str, collections.Mapping[str, str]],
-        /,
-        *,
-        autocomplete: typing.Optional[tanjun.AutocompleteSig[str]] = None,
-        choices: collections.Sequence[tuple[str, str]],
-        converters: typing.Union[collections.Sequence[ConverterSig[str]], ConverterSig[str]] = (),
-        default: typing.Any = tanjun.NO_DEFAULT,
-        key: typing.Optional[str] = None,
-        min_length: typing.Optional[int] = None,
-        max_length: typing.Optional[int] = None,
-        pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
-    ) -> Self:
-        ...
-
-    def add_str_option(
-        self,
-        name: typing.Union[str, collections.Mapping[str, str]],
-        description: typing.Union[str, collections.Mapping[str, str]],
-        /,
-        *,
-        autocomplete: typing.Optional[tanjun.AutocompleteSig[str]] = None,
-        choices: typing.Union[
-            collections.Mapping[str, str],
-            collections.Sequence[str],
-            collections.Sequence[tuple[str, str]],
-            collections.Sequence[hikari.CommandChoice],
-            None,
-        ] = None,
-        converters: typing.Union[collections.Sequence[ConverterSig[str]], ConverterSig[str]] = (),
-        default: typing.Any = tanjun.NO_DEFAULT,
-        key: typing.Optional[str] = None,
-        min_length: typing.Optional[int] = None,
-        max_length: typing.Optional[int] = None,
-        pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
     ) -> Self:
         r"""Add a string option to the slash command.
 
@@ -1962,8 +1888,6 @@ def add_str_option(
             and option_value should be strings of up to 100 characters or a sequence
             of strings where the string will be used for both the choice's name and
             value.
-
-            Passing a sequence of tuples here is deprecated.
         converters
             The option's converters.
 
@@ -2028,21 +1952,8 @@ def add_str_option(
 
         else:
             actual_choices = []
-            warned = False
             for choice in choices:
-                if isinstance(choice, tuple):
-                    if not warned:
-                        warnings.warn(
-                            "Passing a sequence of tuples for 'choices' is deprecated since 2.1.2a1, "
-                            "please pass a mapping instead.",
-                            category=DeprecationWarning,
-                            stacklevel=2 + _stack_level,
-                        )
-                        warned = True
-
-                    actual_choices.append(hikari.CommandChoice(name=choice[0], value=choice[1]))
-
-                elif isinstance(choice, hikari.CommandChoice):
+                if isinstance(choice, hikari.CommandChoice):
                     actual_choices.append(choice)
 
                 else:
@@ -2069,7 +1980,6 @@ def add_str_option(
 
         return self
 
-    @typing.overload
     def add_int_option(
         self,
         name: typing.Union[str, collections.Mapping[str, str]],
@@ -2084,51 +1994,8 @@ def add_int_option(
         min_value: typing.Optional[int] = None,
         max_value: typing.Optional[int] = None,
         pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
     ) -> Self:
         ...
-
-    @typing.overload
-    @typing_extensions.deprecated("Pass a dict for choices, not a sequence of tuples")
-    def add_int_option(
-        self,
-        name: typing.Union[str, collections.Mapping[str, str]],
-        description: typing.Union[str, collections.Mapping[str, str]],
-        /,
-        *,
-        autocomplete: typing.Optional[tanjun.AutocompleteSig[int]] = None,
-        choices: collections.Sequence[tuple[str, int]],
-        converters: typing.Union[collections.Sequence[ConverterSig[int]], ConverterSig[int]] = (),
-        default: typing.Any = tanjun.NO_DEFAULT,
-        key: typing.Optional[str] = None,
-        min_value: typing.Optional[int] = None,
-        max_value: typing.Optional[int] = None,
-        pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
-    ) -> Self:
-        ...
-
-    def add_int_option(
-        self,
-        name: typing.Union[str, collections.Mapping[str, str]],
-        description: typing.Union[str, collections.Mapping[str, str]],
-        /,
-        *,
-        autocomplete: typing.Optional[tanjun.AutocompleteSig[int]] = None,
-        choices: typing.Union[
-            collections.Mapping[str, int],
-            collections.Sequence[tuple[str, int]],
-            collections.Sequence[hikari.CommandChoice],
-            None,
-        ] = None,
-        converters: typing.Union[collections.Sequence[ConverterSig[int]], ConverterSig[int]] = (),
-        default: typing.Any = tanjun.NO_DEFAULT,
-        key: typing.Optional[str] = None,
-        min_value: typing.Optional[int] = None,
-        max_value: typing.Optional[int] = None,
-        pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
-    ) -> Self:
         r"""Add an integer option to the slash command.
 
         Parameters
@@ -2218,7 +2085,6 @@ def add_int_option(
             min_value=min_value,
             max_value=max_value,
             pass_as_kwarg=pass_as_kwarg,
-            _stack_level=_stack_level + 1,
         )
 
         if autocomplete:
@@ -2226,7 +2092,6 @@ def add_int_option(
 
         return self
 
-    @typing.overload
     def add_float_option(
         self,
         name: typing.Union[str, collections.Mapping[str, str]],
@@ -2242,52 +2107,6 @@ def add_float_option(
         min_value: typing.Optional[float] = None,
         max_value: typing.Optional[float] = None,
         pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
-    ) -> Self:
-        ...
-
-    @typing.overload
-    @typing_extensions.deprecated("Pass a dict for choices, not a sequence of tuples")
-    def add_float_option(
-        self,
-        name: typing.Union[str, collections.Mapping[str, str]],
-        description: typing.Union[str, collections.Mapping[str, str]],
-        /,
-        *,
-        always_float: bool = True,
-        autocomplete: typing.Optional[tanjun.AutocompleteSig[float]] = None,
-        choices: collections.Sequence[tuple[str, float]],
-        converters: typing.Union[collections.Sequence[ConverterSig[float]], ConverterSig[float]] = (),
-        default: typing.Any = tanjun.NO_DEFAULT,
-        key: typing.Optional[str] = None,
-        min_value: typing.Optional[float] = None,
-        max_value: typing.Optional[float] = None,
-        pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
-    ) -> Self:
-        ...
-
-    def add_float_option(
-        self,
-        name: typing.Union[str, collections.Mapping[str, str]],
-        description: typing.Union[str, collections.Mapping[str, str]],
-        /,
-        *,
-        always_float: bool = True,
-        autocomplete: typing.Optional[tanjun.AutocompleteSig[float]] = None,
-        choices: typing.Union[
-            collections.Mapping[str, float],
-            collections.Sequence[tuple[str, float]],
-            collections.Sequence[hikari.CommandChoice],
-            None,
-        ] = None,
-        converters: typing.Union[collections.Sequence[ConverterSig[float]], ConverterSig[float]] = (),
-        default: typing.Any = tanjun.NO_DEFAULT,
-        key: typing.Optional[str] = None,
-        min_value: typing.Optional[float] = None,
-        max_value: typing.Optional[float] = None,
-        pass_as_kwarg: bool = True,
-        _stack_level: int = 0,
     ) -> Self:
         r"""Add a float option to a slash command.
 
@@ -2385,7 +2204,6 @@ def add_float_option(
             max_value=float(max_value) if max_value is not None else None,
             pass_as_kwarg=pass_as_kwarg,
             always_float=always_float,
-            _stack_level=_stack_level + 1,
         )
 
         if autocomplete:
diff --git a/tanjun/conversion.py b/tanjun/conversion.py
index ed2195501..7230646e9 100644
--- a/tanjun/conversion.py
+++ b/tanjun/conversion.py
@@ -74,9 +74,7 @@
 ]
 
 import datetime
-import functools
 import logging
-import operator
 import re
 import typing
 import urllib.parse as urlparse
@@ -84,7 +82,6 @@
 
 import alluka
 import hikari
-import typing_extensions
 
 from . import _internal
 from . import abc as tanjun
@@ -119,21 +116,6 @@ class BaseConverter:
 
     __slots__ = ("__weakref__",)
 
-    @property
-    @typing_extensions.deprecated("Use .caches instead")
-    def async_caches(self) -> collections.Sequence[typing.Any]:
-        """Deprecated property."""
-        return list({v[0] for v in self.caches})
-
-    @property
-    @typing_extensions.deprecated("Use .caches instead")
-    def cache_components(self) -> hikari.api.CacheComponents:
-        """Deprecated property."""
-        if self.caches:
-            return functools.reduce(operator.ior, (v[1] for v in self.caches))
-
-        return hikari.api.CacheComponents.NONE
-
     @property
     def caches(self) -> collections.Sequence[tuple[typing.Any, hikari.api.CacheComponents, hikari.Intents]]:
         """Caches the converter takes advantage of.
@@ -148,15 +130,6 @@ def caches(self) -> collections.Sequence[tuple[typing.Any, hikari.api.CacheCompo
         """
         return []
 
-    @property
-    @typing_extensions.deprecated("Use .caches instead")
-    def intents(self) -> hikari.Intents:
-        """Deprecated property."""
-        if self.caches:
-            return functools.reduce(operator.ior, (v[2] for v in self.caches))
-
-        return hikari.Intents.NONE
-
     @property
     def requires_cache(self) -> bool:
         """Whether this converter relies on the relevant cache stores to work.
@@ -388,13 +361,6 @@ async def __call__(
         raise ValueError("Couldn't find channel")
 
 
-@typing_extensions.deprecated("Use ToChannel instead")
-class ChannelConverter(ToChannel):
-    """Deprecated alias of [ToChannel][tanjun.conversion.ToChannel]."""
-
-    __slots__ = ()
-
-
 _EmojiCacheT = async_cache.SfCache[hikari.KnownCustomEmoji]
 
 
@@ -454,13 +420,6 @@ async def __call__(
         raise ValueError("Couldn't find emoji")
 
 
-@typing_extensions.deprecated("Use ToEmoji")
-class EmojiConverter(ToEmoji):
-    """Deprecated alias of [ToEmoji][tanjun.conversion.ToEmoji]."""
-
-    __slots__ = ()
-
-
 _GuildCacheT = async_cache.SfCache[hikari.Guild]
 
 
@@ -508,13 +467,6 @@ async def __call__(
         raise ValueError("Couldn't find guild")
 
 
-@typing_extensions.deprecated("Use ToGuild")
-class GuildConverter(ToGuild):
-    """Deprecated alias of [ToGuild][tanjun.conversion.ToGuild]."""
-
-    __slots__ = ()
-
-
 _InviteCacheT = async_cache.AsyncCache[str, hikari.InviteWithMetadata]
 
 
@@ -557,13 +509,6 @@ async def __call__(
         raise ValueError("Couldn't find invite")
 
 
-@typing_extensions.deprecated("Use ToInvite")
-class InviteConverter(ToInvite):
-    """Deprecated alias of [ToInvite][tanjun.conversion.ToInvite]."""
-
-    __slots__ = ()
-
-
 class ToInviteWithMetadata(BaseConverter):
     """Standard converter for invites with metadata.
 
@@ -604,13 +549,6 @@ async def __call__(
         raise ValueError("Couldn't find invite")
 
 
-@typing_extensions.deprecated("Use ToInviteWithMetadata")
-class InviteWithMetadataConverter(ToInviteWithMetadata):
-    """Deprecated alias of [ToInviteWithMetadata][tanjun.conversion.ToInviteWithMetadata]."""
-
-    __slots__ = ()
-
-
 _MemberCacheT = async_cache.SfGuildBound[hikari.Member]
 
 
@@ -677,13 +615,6 @@ async def __call__(
         raise ValueError("Couldn't find member in this guild")
 
 
-@typing_extensions.deprecated("Use ToMember")
-class MemberConverter(ToMember):
-    """Deprecated alias of [ToMember][tanjun.conversion.ToMember]."""
-
-    __slots__ = ()
-
-
 _PresenceCacheT = async_cache.SfGuildBound[hikari.MemberPresence]
 
 
@@ -734,13 +665,6 @@ async def __call__(
         raise ValueError("Couldn't find presence in current guild")
 
 
-@typing_extensions.deprecated("Use ToPresence")
-class PresenceConverter(ToPresence):
-    """Deprecated alias of [ToPresence][tanjun.conversion.ToPresence]."""
-
-    __slots__ = ()
-
-
 _RoleCacheT = async_cache.SfCache[hikari.Role]
 
 
@@ -786,13 +710,6 @@ async def __call__(
         raise ValueError("Couldn't find role")
 
 
-@typing_extensions.deprecated("Use ToRole")
-class RoleConverter(ToRole):
-    """Deprecated alias of [ToRole][tanjun.conversion.ToRole]."""
-
-    __slots__ = ()
-
-
 _UserCacheT = async_cache.SfCache[hikari.User]
 
 
@@ -841,13 +758,6 @@ async def __call__(
         raise ValueError("Couldn't find user")
 
 
-@typing_extensions.deprecated("Use ToUser")
-class UserConverter(ToUser):
-    """Deprecated alias of [ToUser][tanjun.conversion.ToUser]."""
-
-    __slots__ = ()
-
-
 _MessageCacheT = async_cache.SfCache[hikari.Message]
 
 
@@ -953,13 +863,6 @@ async def __call__(
         raise ValueError("Voice state couldn't be found for current guild")
 
 
-@typing_extensions.deprecated("Use ToVoiceState")
-class VoiceStateConverter(ToVoiceState):
-    """Deprecated alias of [ToVoiceState][tanjun.conversion.ToVoiceState]."""
-
-    __slots__ = ()
-
-
 class _IDMatcherSigProto(typing.Protocol):
     def __call__(self, value: _SnowflakeIsh, /, *, message: str = "No valid mention or ID found") -> hikari.Snowflake:
         raise NotImplementedError
diff --git a/tanjun/dependencies/limiters.py b/tanjun/dependencies/limiters.py
index 05d8e24b8..b5827027a 100644
--- a/tanjun/dependencies/limiters.py
+++ b/tanjun/dependencies/limiters.py
@@ -62,7 +62,6 @@
 
 import alluka
 import hikari
-import typing_extensions
 
 from .. import _internal
 from .. import abc as tanjun
@@ -115,30 +114,6 @@ class AbstractCooldownManager(abc.ABC):
 
     __slots__ = ()
 
-    @typing_extensions.deprecated("Use .acquire and .release")
-    @abc.abstractmethod
-    async def check_cooldown(
-        self, bucket_id: str, ctx: tanjun.Context, /, *, increment: bool = False
-    ) -> typing.Optional[datetime.datetime]:
-        """Deprecated method."""
-
-    @typing_extensions.deprecated("Use .acquire and .release")
-    async def increment_cooldown(self, bucket_id: str, ctx: tanjun.Context, /) -> None:
-        """Deprecated function for incrementing a cooldown.
-
-        Use
-        [AbstractCooldownManager.acquire][tanjun.dependencies.limiters.AbstractCooldownManager.acquire]
-        and [AbstractCooldownManager.release][tanjun.dependencies.limiters.AbstractCooldownManager.release].
-        """
-        try:
-            await self.try_acquire(bucket_id, ctx)
-
-        except ResourceDepleted:
-            pass
-
-        else:
-            await self.release(bucket_id, ctx)
-
     @abc.abstractmethod
     async def try_acquire(self, bucket_id: str, ctx: tanjun.Context, /) -> None:
         """Increment a bucket's cooldown.
@@ -808,37 +783,6 @@ async def try_acquire(self, bucket_id: str, ctx: tanjun.Context) -> None:
         resource = await bucket.into_inner(ctx)
         self._acquiring_ctxs[key] = resource.check().increment(ctx)
 
-    @typing_extensions.deprecated("Use .acquire and .release")
-    async def check_cooldown(
-        self, bucket_id: str, ctx: tanjun.Context, /, *, increment: bool = False
-    ) -> typing.Optional[datetime.datetime]:
-        if increment:
-            try:
-                await self.try_acquire(bucket_id, ctx)
-
-            except CooldownDepleted as exc:
-                return exc.wait_until or (_now() + _ASSUMED_COOLDOWN_DELTA)
-
-            else:
-                await self.release(bucket_id, ctx)
-
-        else:
-            resource = (
-                self._acquiring_ctxs.get((bucket_id, ctx))
-                or (bucket := self._buckets.get(bucket_id))
-                and (resource := await bucket.into_inner(ctx))
-            )
-            if not resource:
-                return None  # MyPy compat
-
-            try:
-                resource.check()
-
-            except CooldownDepleted as exc:
-                return exc.wait_until or (_now() + _ASSUMED_COOLDOWN_DELTA)
-
-        return None  # MyPy compat
-
     async def release(self, bucket_id: str, ctx: tanjun.Context, /) -> None:
         if resource := self._custom_buckets.get(bucket_id):
             return await resource.release(bucket_id, ctx)
diff --git a/tanjun/injecting.py b/tanjun/injecting.py
deleted file mode 100644
index c2f89f360..000000000
--- a/tanjun/injecting.py
+++ /dev/null
@@ -1,112 +0,0 @@
-# -*- coding: utf-8 -*-
-# BSD 3-Clause License
-#
-# Copyright (c) 2020-2023, Faster Speeding
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-#
-# * Neither the name of the copyright holder nor the names of its
-#   contributors may be used to endorse or promote products derived from
-#   this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""Aliases of the types and implementations used for dependency injection.
-
-!!! warning "deprecated"
-    This module consists solely of deprecated aliases to types and functions
-    from the separate `alluka` dependency injection library kept for backwards
-    compatibility.
-"""
-from __future__ import annotations
-
-__all__: list[str] = [
-    "AbstractInjectionContext",
-    "BasicInjectionContext",
-    "CallbackSig",
-    "Injected",
-    "InjectorClient",
-    "SelfInjectingCallback",
-    "UNDEFINED",
-    "Undefined",
-    "UndefinedOr",
-    "as_self_injecting",
-    "inject",
-    "injected",
-]
-
-import collections.abc as collections
-import typing
-
-import alluka
-from alluka import AsyncSelfInjecting as SelfInjectingCallback
-from alluka import BasicContext as BasicInjectionContext
-from alluka import Client as InjectorClient
-from alluka import Injected
-from alluka import inject
-from alluka import inject as injected
-from alluka.abc import UNDEFINED
-from alluka.abc import CallbackSig
-from alluka.abc import Context as AbstractInjectionContext
-from alluka.abc import Undefined
-
-if typing.TYPE_CHECKING:
-    from . import abc as tanjun
-
-_T = typing.TypeVar("_T")
-_CallbackSigT = typing.TypeVar("_CallbackSigT", bound=alluka.abc.CallbackSig[typing.Any])
-
-UndefinedOr = typing.Union[Undefined, _T]
-"""Type-hint generic union used to indicate that a value may be undefined or `_T`."""
-
-
-def as_self_injecting(
-    client: tanjun.Client, /
-) -> collections.Callable[[_CallbackSigT], alluka.AsyncSelfInjecting[_CallbackSigT]]:
-    """Make a callback self-inecting by linking it to a client through a decorator call.
-
-    Examples
-    --------
-    ```py
-    def make_callback(client: tanjun.Client) -> collections.abc.Callable[[], int]:
-        @tanjun.as_self_injected(client)
-        async def get_int_value(
-            redis: redis.Client = tanjun.inject(type=redis.Client)
-        ) -> int:
-            return int(await redis.get('key'))
-
-        return get_int_value
-    ```
-
-    Parameters
-    ----------
-    client : tanjun.abc.Client
-        The client to use to resolve dependencies.
-
-    Returns
-    -------
-    collections.abc.Callable[[alluka.abc.CallbackSig], alluka.AsyncSelfInjecting]
-        Decorator callback that returns a self-injecting callback.
-    """
-
-    def decorator(callback: _CallbackSigT, /) -> alluka.AsyncSelfInjecting[_CallbackSigT]:
-        return alluka.AsyncSelfInjecting(client.injector, callback)
-
-    return decorator
diff --git a/tanjun/parsing.py b/tanjun/parsing.py
index 103913485..e0e3e8b55 100644
--- a/tanjun/parsing.py
+++ b/tanjun/parsing.py
@@ -106,19 +106,6 @@ def __len__(self) -> int:
     )
 
 
-UndefinedT = typing.Literal[tanjun.NO_DEFAULT]
-"""Deprecated alias of `typing.Literal[tanjun.abc.NO_DEFAULT]`."""
-
-UndefinedDefaultT = typing.Literal[tanjun.NO_DEFAULT]
-"""Deprecated alias of `typing.Literal[tanjun.abc.NO_DEFAULT]`."""
-
-UNDEFINED = tanjun.NO_DEFAULT
-"""Deprecated alias of [tanjun.abc.NO_DEFAULT][]."""
-
-UNDEFINED_DEFAULT = tanjun.NO_DEFAULT
-"""Deprecated alias of [tanjun.abc.NO_DEFAULT][]."""
-
-
 class AbstractOptionParser(tanjun.MessageParser, abc.ABC):
     """Abstract interface of a message content parser."""
 
@@ -460,13 +447,6 @@ def add_option(
         """
 
 
-@typing_extensions.deprecated("Use AbstractOptionParser")
-class AbstractParser(AbstractOptionParser):
-    """Deprecated alias of [AbstractOptionParser][tanjun.parsing.AbstractOptionParser]."""
-
-    __slots__ = ()
-
-
 class _ShlexTokenizer:
     __slots__ = ("__arg_buffer", "__last_name", "__options_buffer", "__shlex")
 
diff --git a/tanjun/utilities.py b/tanjun/utilities.py
deleted file mode 100644
index c61f177cf..000000000
--- a/tanjun/utilities.py
+++ /dev/null
@@ -1,48 +0,0 @@
-# -*- coding: utf-8 -*-
-# BSD 3-Clause License
-#
-# Copyright (c) 2020-2023, Faster Speeding
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-#
-# * Neither the name of the copyright holder nor the names of its
-#   contributors may be used to endorse or promote products derived from
-#   this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-"""Deprecated alias of [tanjun.permissions][]."""
-from __future__ import annotations
-
-__all__: list[str] = [
-    "ALL_PERMISSIONS",
-    "DM_PERMISSIONS",
-    "calculate_everyone_permissions",
-    "calculate_permissions",
-    "fetch_everyone_permissions",
-    "fetch_permissions",
-]
-
-from .permissions import ALL_PERMISSIONS
-from .permissions import DM_PERMISSIONS
-from .permissions import calculate_everyone_permissions
-from .permissions import calculate_permissions
-from .permissions import fetch_everyone_permissions
-from .permissions import fetch_permissions
diff --git a/tests/commands/test_menu.py b/tests/commands/test_menu.py
index 71d566f52..dd01b7b64 100644
--- a/tests/commands/test_menu.py
+++ b/tests/commands/test_menu.py
@@ -250,8 +250,8 @@ def test__init__when_localised_default_name_too_short(self):
     def test___init___when_command_object(
         self,
         inner_command: typing.Union[
-            tanjun.SlashCommand[tanjun.abc.CommandCallbackSig],
-            tanjun.MessageCommand[tanjun.abc.CommandCallbackSig],
+            tanjun.SlashCommand[tanjun.abc.SlashCallbackSig],
+            tanjun.MessageCommand[tanjun.abc.MessageCallbackSig],
             tanjun.MenuCommand[typing.Any, typing.Any],
         ],
     ):
diff --git a/tests/commands/test_message.py b/tests/commands/test_message.py
index f5dfbd0ae..618b65959 100644
--- a/tests/commands/test_message.py
+++ b/tests/commands/test_message.py
@@ -139,7 +139,7 @@ class TestMessageCommand:
     def test___init___when_command_object(
         self,
         inner_command: typing.Union[
-            tanjun.SlashCommand[tanjun.abc.CommandCallbackSig], tanjun.MenuCommand[typing.Any, typing.Any]
+            tanjun.SlashCommand[tanjun.abc.SlashCallbackSig], tanjun.MenuCommand[typing.Any, typing.Any]
         ],
     ):
         assert tanjun.MessageCommand(inner_command, "woow").callback is inner_command.callback
diff --git a/tests/commands/test_slash.py b/tests/commands/test_slash.py
index e1f524833..61c933609 100644
--- a/tests/commands/test_slash.py
+++ b/tests/commands/test_slash.py
@@ -232,7 +232,6 @@ def test_with_str_slash_option():
         min_length=543,
         max_length=6543,
         pass_as_kwarg=False,
-        _stack_level=1,
     )
 
 
@@ -253,7 +252,6 @@ def test_with_str_slash_option_with_defaults():
         min_length=None,
         max_length=None,
         pass_as_kwarg=True,
-        _stack_level=1,
     )
 
 
@@ -287,7 +285,6 @@ def test_with_int_slash_option():
         min_value=1123,
         max_value=312123,
         pass_as_kwarg=False,
-        _stack_level=1,
     )
 
 
@@ -308,7 +305,6 @@ def test_with_int_slash_option_with_defaults():
         min_value=None,
         max_value=None,
         pass_as_kwarg=True,
-        _stack_level=1,
     )
 
 
@@ -344,7 +340,6 @@ def test_with_float_slash_option():
         min_value=56.234,
         max_value=765.234,
         pass_as_kwarg=False,
-        _stack_level=1,
     )
 
 
@@ -366,7 +361,6 @@ def test_with_float_slash_option_with_defaults():
         min_value=None,
         max_value=None,
         pass_as_kwarg=True,
-        _stack_level=1,
     )
 
 
@@ -1317,8 +1311,8 @@ class TestSlashCommand:
     def test___init___when_command_object(
         self,
         inner_command: typing.Union[
-            tanjun.SlashCommand[tanjun.abc.CommandCallbackSig],
-            tanjun.MessageCommand[tanjun.abc.CommandCallbackSig],
+            tanjun.SlashCommand[tanjun.abc.SlashCallbackSig],
+            tanjun.MessageCommand[tanjun.abc.MessageCallbackSig],
             tanjun.MenuCommand[typing.Any, typing.Any],
         ],
     ):
@@ -1622,23 +1616,6 @@ def test_add_str_option_with_choices_object_list(self, command: tanjun.SlashComm
         assert option.choices == [choice_1, choice_2, choice_3]
         assert option.name in command._tracked_options
 
-    def test_add_str_option_with_deprecated_choices_tuple_list(self, command: tanjun.SlashCommand[typing.Any]):
-        with pytest.warns(DeprecationWarning):
-            command.add_str_option(
-                "boom",
-                "No u",
-                choices=[("gay", "Gay"), "no", ("lesbian_bi", "Lesbian Bi"), ("transive", "Trans")],  # type: ignore
-            )
-
-        option = command.build().options[0]
-        assert option.choices == [
-            hikari.CommandChoice(name="gay", value="Gay"),
-            hikari.CommandChoice(name="No", value="no"),
-            hikari.CommandChoice(name="lesbian_bi", value="Lesbian Bi"),
-            hikari.CommandChoice(name="transive", value="Trans"),
-        ]
-        assert option.name in command._tracked_options
-
     def test_add_str_option_with_defaults(self, command: tanjun.SlashCommand[typing.Any]):
         command.add_str_option("boom", "No u")
 
@@ -1891,14 +1868,6 @@ def test_add_int_option_when_min_greater_than_max(self, command: tanjun.SlashCom
         with pytest.raises(ValueError, match="`min_value` cannot be greater than `max_value`"):
             command.add_int_option("sesese", "asasasa", min_value=33232, max_value=2232)
 
-    def test_add_int_option_with_deprecated_choices_tuple_list(self, command: tanjun.SlashCommand[typing.Any]):
-        with pytest.warns(DeprecationWarning):
-            command.add_int_option("see", "seesee", choices=[("les", 1), ("g", 43)])  # type: ignore
-
-        option = command.build().options[0]
-        assert option.choices == [hikari.CommandChoice(name="les", value=1), hikari.CommandChoice(name="g", value=43)]
-        assert option.name in command._tracked_options
-
     def test_add_int_option_with_choices_object_list(self, command: tanjun.SlashCommand[typing.Any]):
         choice_1 = hikari.CommandChoice(name="a", name_localizations={"b": "c"}, value="d")
         choice_2 = hikari.CommandChoice(name="e", name_localizations={"f": "g"}, value="h")
@@ -2138,17 +2107,6 @@ def test_add_float_option_with_choices_object_list(self, command: tanjun.SlashCo
         assert option.choices == [choice_1, choice_2, choice_3]
         assert option.name in command._tracked_options
 
-    def test_add_float_option_with_deprecated_choices_tuple_list(self, command: tanjun.SlashCommand[typing.Any]):
-        with pytest.warns(DeprecationWarning):
-            command.add_float_option("easy", "aaa", choices=[("blam", 4.20), ("blam2", 6.9)])  # type: ignore
-
-        option = command.build().options[0]
-        assert option.choices == [
-            hikari.CommandChoice(name="blam", value=4.20),
-            hikari.CommandChoice(name="blam2", value=6.9),
-        ]
-        assert option.name in command._tracked_options
-
     def test_add_float_option_with_defaults(self, command: tanjun.SlashCommand[typing.Any]):
         command.add_float_option("easy", "aaa")
 
diff --git a/tests/dependencies/test_limiters.py b/tests/dependencies/test_limiters.py
index 5c3718f57..6902492e0 100644
--- a/tests/dependencies/test_limiters.py
+++ b/tests/dependencies/test_limiters.py
@@ -38,7 +38,6 @@
 import typing
 
 import alluka
-import freezegun
 import hikari
 import mock
 import pytest
@@ -52,50 +51,6 @@ def _now() -> datetime.datetime:
 
 
 class TestAbstractCooldownManager:
-    @pytest.mark.asyncio()
-    async def test_increment_cooldown(self):
-        mock_try_acquire = mock.AsyncMock()
-        mock_release = mock.AsyncMock()
-
-        class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
-            __slots__ = ()
-
-            try_acquire = mock_try_acquire
-            release = mock_release
-            check = check_cooldown = mock.AsyncMock()
-
-        manager = CooldownManager()
-
-        mock_context = mock.Mock()
-
-        with pytest.warns(DeprecationWarning):
-            await manager.increment_cooldown("catgirl neko", mock_context)
-
-        mock_try_acquire.assert_awaited_once_with("catgirl neko", mock_context)
-        mock_release.assert_awaited_once_with("catgirl neko", mock_context)
-
-    @pytest.mark.asyncio()
-    async def test_increment_cooldown_when_resource_depleted(self):
-        mock_try_acquire = mock.AsyncMock(side_effect=tanjun.dependencies.limiters.CooldownDepleted(None))
-        mock_release = mock.AsyncMock()
-
-        class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
-            __slots__ = ()
-
-            try_acquire = mock_try_acquire
-            release = mock_release
-            check = check_cooldown = mock.AsyncMock()
-
-        manager = CooldownManager()
-
-        mock_context = mock.Mock()
-
-        with pytest.warns(DeprecationWarning):
-            await manager.increment_cooldown("catgirl neko", mock_context)
-
-        mock_try_acquire.assert_awaited_once_with("catgirl neko", mock_context)
-        mock_release.assert_not_called()
-
     @pytest.mark.asyncio()
     async def test_acquire(self):
         mock_try_acquire = mock.AsyncMock()
@@ -108,7 +63,7 @@ class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
 
             try_acquire = mock_try_acquire
             release = mock_release
-            check = check_cooldown = mock.AsyncMock()
+            check = mock.AsyncMock()
 
         manager = CooldownManager()
 
@@ -132,7 +87,7 @@ class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
 
             try_acquire = mock_try_acquire
             release = mock_release
-            check = check_cooldown = mock.AsyncMock()
+            check = mock.AsyncMock()
 
         manager = CooldownManager()
 
@@ -162,7 +117,7 @@ class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
 
             try_acquire = mock_try_acquire
             release = mock_release
-            check = check_cooldown = mock.AsyncMock()
+            check = mock.AsyncMock()
 
         manager = CooldownManager()
 
@@ -185,7 +140,7 @@ class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
 
             try_acquire = mock_try_acquire
             release = mock_release
-            check = check_cooldown = mock.AsyncMock()
+            check = mock.AsyncMock()
 
         manager = CooldownManager()
 
@@ -211,7 +166,7 @@ class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
 
             try_acquire = mock_try_acquire
             release = mock_release
-            check = check_cooldown = mock.AsyncMock()
+            check = mock.AsyncMock()
 
         manager = CooldownManager()
 
@@ -236,7 +191,7 @@ class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
 
             try_acquire = mock_try_acquire
             release = mock_release
-            check = check_cooldown = mock.AsyncMock()
+            check = mock.AsyncMock()
 
         manager = CooldownManager()
         acquire = manager.acquire("oop", mock_ctx)
@@ -265,7 +220,7 @@ class CooldownManager(tanjun.dependencies.AbstractCooldownManager):
 
             try_acquire = mock_try_acquire
             release = mock_release
-            check = check_cooldown = mock.AsyncMock()
+            check = mock.AsyncMock()
 
         manager = CooldownManager()
 
@@ -1357,159 +1312,6 @@ async def test_release_with_custom_bucket(self):
 
         mock_bucket.release.assert_awaited_once_with("meowers meowers", mock_context)
 
-    @pytest.mark.asyncio()
-    async def test_check_cooldown(self):
-        mock_bucket = mock.AsyncMock()
-        mock_bucket.into_inner.return_value = mock.Mock()
-        mock_ctx = mock.Mock()
-        manager = tanjun.dependencies.InMemoryCooldownManager()
-        manager._buckets["echo"] = mock_bucket
-
-        with pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("echo", mock_ctx)
-
-        assert result is None
-        mock_bucket.into_inner.assert_awaited_once_with(mock_ctx)
-        mock_bucket.into_inner.return_value.check.assert_called_once_with()
-
-    @pytest.mark.asyncio()
-    async def test_check_cooldown_for_acquired_context(self):
-        mock_resource = mock.Mock()
-        mock_ctx = mock.Mock()
-        manager = tanjun.dependencies.InMemoryCooldownManager()
-        manager._acquiring_ctxs["mortal", mock_ctx] = mock_resource
-
-        with pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("mortal", mock_ctx)
-
-        assert result is None
-        mock_resource.check.assert_called_once_with()
-
-    @pytest.mark.asyncio()
-    async def test_check_cooldown_when_cooldown_depleted(self):
-        date = _now()
-        mock_bucket = mock.AsyncMock()
-        mock_bucket.into_inner.return_value.check = mock.Mock(
-            side_effect=tanjun.dependencies.limiters.CooldownDepleted(date)
-        )
-        mock_ctx = mock.Mock()
-        manager = tanjun.dependencies.InMemoryCooldownManager()
-        manager._buckets["meep"] = mock_bucket
-
-        with pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("meep", mock_ctx)
-
-        assert result is date
-        mock_bucket.into_inner.assert_awaited_once_with(mock_ctx)
-        mock_bucket.into_inner.return_value.check.assert_called_once_with()
-
-    @pytest.mark.asyncio()
-    async def test_check_cooldown_for_acquired_context_when_cooldown_depleted(self):
-        date = _now()
-        mock_resource = mock.Mock()
-        mock_resource.check.side_effect = tanjun.dependencies.limiters.CooldownDepleted(date)
-        mock_ctx = mock.Mock()
-        manager = tanjun.dependencies.InMemoryCooldownManager()
-        manager._acquiring_ctxs[("eeep", mock_ctx)] = mock_resource
-
-        with pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("eeep", mock_ctx)
-
-        assert result is date
-        mock_resource.check.assert_called_once_with()
-
-    @pytest.mark.asyncio()
-    async def test_check_cooldown_when_cooldown_depleted_unknown_wait_until(self):
-        mock_bucket = mock.AsyncMock()
-        mock_bucket.into_inner.return_value.check = mock.Mock(
-            side_effect=tanjun.dependencies.limiters.CooldownDepleted(None)
-        )
-        mock_ctx = mock.Mock()
-        manager = tanjun.dependencies.InMemoryCooldownManager()
-        manager._buckets["flirt"] = mock_bucket
-
-        date = datetime.datetime(2022, 5, 27, 23, 2, 40, 527391, tzinfo=datetime.timezone.utc)
-        with freezegun.freeze_time(date), pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("flirt", mock_ctx)
-
-        assert result == datetime.datetime(2022, 5, 27, 23, 3, 40, 527391, tzinfo=datetime.timezone.utc)
-        mock_bucket.into_inner.assert_awaited_once_with(mock_ctx)
-        mock_bucket.into_inner.return_value.check.assert_called_once_with()
-
-    @pytest.mark.asyncio()
-    async def test_check_cooldown_for_acquired_context_when_cooldown_depleted_unknown_wait_until(self):
-        mock_resource = mock.Mock()
-        mock_resource.check.side_effect = tanjun.dependencies.limiters.CooldownDepleted(None)
-        mock_ctx = mock.Mock()
-        manager = tanjun.dependencies.InMemoryCooldownManager()
-        manager._acquiring_ctxs[("mother", mock_ctx)] = mock_resource
-
-        date = datetime.datetime(2021, 5, 27, 23, 2, 40, 527391, tzinfo=datetime.timezone.utc)
-        with freezegun.freeze_time(date), pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("mother", mock_ctx)
-
-        assert result == datetime.datetime(2021, 5, 27, 23, 3, 40, 527391, tzinfo=datetime.timezone.utc)
-        mock_resource.check.assert_called_once_with()
-
-    @pytest.mark.asyncio()
-    async def test_check_cooldown_when_increment(self):
-        mock_try_acquire = mock.AsyncMock()
-        mock_release = mock.AsyncMock()
-        mock_ctx = mock.Mock()
-
-        class CooldownManager(tanjun.InMemoryCooldownManager):
-            try_acquire = mock_try_acquire
-            release = mock_release
-
-        manager = CooldownManager()
-
-        with pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("yeet", mock_ctx, increment=True)
-
-        assert result is None
-        mock_try_acquire.assert_awaited_once_with("yeet", mock_ctx)
-        mock_release.assert_awaited_once_with("yeet", mock_ctx)
-
-    @pytest.mark.asyncio()
-    async def test_check_cooldown_when_increment_and_cooldown_depleted(self):
-        date = _now()
-        mock_try_acquire = mock.AsyncMock(side_effect=tanjun.dependencies.limiters.CooldownDepleted(date))
-        mock_release = mock.AsyncMock()
-        mock_ctx = mock.Mock()
-
-        class CooldownManager(tanjun.InMemoryCooldownManager):
-            try_acquire = mock_try_acquire
-            release = mock_release
-
-        manager = CooldownManager()
-
-        with pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("yeet", mock_ctx, increment=True)
-
-        assert result is date
-        mock_try_acquire.assert_awaited_once_with("yeet", mock_ctx)
-        mock_release.assert_not_called()
-
-    @pytest.mark.asyncio()
-    async def test_check_cooldown_when_increment_and_cooldown_depleted_with_unknown_wait_until(self):
-        mock_try_acquire = mock.AsyncMock(side_effect=tanjun.dependencies.limiters.CooldownDepleted(None))
-        mock_release = mock.AsyncMock()
-        mock_ctx = mock.Mock()
-
-        class CooldownManager(tanjun.InMemoryCooldownManager):
-            try_acquire = mock_try_acquire
-            release = mock_release
-
-        manager = CooldownManager()
-
-        date = datetime.datetime(2023, 5, 27, 23, 2, 40, 527391, tzinfo=datetime.timezone.utc)
-        with freezegun.freeze_time(date), pytest.warns(DeprecationWarning, match="Use .acquire and .release"):
-            result = await manager.check_cooldown("yeet", mock_ctx, increment=True)
-
-        assert result == datetime.datetime(2023, 5, 27, 23, 3, 40, 527391, tzinfo=datetime.timezone.utc)
-        mock_try_acquire.assert_awaited_once_with("yeet", mock_ctx)
-        mock_release.assert_not_called()
-
     def test_close(self):
         manager = tanjun.dependencies.InMemoryCooldownManager()
         mock_gc_task = mock.Mock()
diff --git a/tests/test_annotations.py b/tests/test_annotations.py
index fb6000e20..5501a8033 100644
--- a/tests/test_annotations.py
+++ b/tests/test_annotations.py
@@ -31,7 +31,6 @@
 
 # pyright: reportPrivateUsage=none
 
-import enum
 import inspect
 import re
 import sys
@@ -97,17 +96,6 @@ def test_properties_with_default_values(self):
         assert flag.aliases is None
         assert flag.empty_value is tanjun.abc.NO_DEFAULT
 
-    def test_deprecated_default(self):
-        value = object()
-
-        with pytest.warns(
-            DeprecationWarning, match=re.escape("Flag.__init__'s `default` argument is deprecated, use Default instead")
-        ):
-            flag = annotations.Flag(default=value)  # pyright: ignore[reportDeprecated]
-
-        with pytest.warns(DeprecationWarning, match=re.escape("Use annotations.Default instead of the default arg")):
-            assert flag.default is value
-
 
 class TestLength:
     def test_properties(self):
@@ -810,311 +798,6 @@ async def callback(
         annotations.with_annotated_args(callback)
 
 
-def test_with_generic_float_choices():
-    class Choices(float, enum.Enum):
-        Foo = 123.321
-        Bar = 543.123
-        Blam = 432.123
-        Ok = 43.34
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            nom: typing.Annotated[annotations.Choices[Choices], "description"],  # type: ignore
-            boom: typing.Annotated[annotations.Choices[Choices], "bag"] = Choices.Blam,  # type: ignore
-        ):
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
-            name="nom",
-            channel_types=None,
-            description="description",
-            is_required=True,
-            choices=[
-                hikari.CommandChoice(name="Foo", value=123.321),
-                hikari.CommandChoice(name="Bar", value=543.123),
-                hikari.CommandChoice(name="Blam", value=432.123),
-                hikari.CommandChoice(name="Ok", value=43.34),
-            ],
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
-            name="boom",
-            channel_types=None,
-            description="bag",
-            is_required=False,
-            choices=[
-                hikari.CommandChoice(name="Foo", value=123.321),
-                hikari.CommandChoice(name="Bar", value=543.123),
-                hikari.CommandChoice(name="Blam", value=432.123),
-                hikari.CommandChoice(name="Ok", value=43.34),
-            ],
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["nom"]
-    assert tracked_option.converters == [Choices]
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is True
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "nom"
-    assert tracked_option.name == "nom"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    tracked_option = callback._tracked_options["boom"]
-    assert tracked_option.converters == [Choices]
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is True
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "boom"
-    assert tracked_option.name == "boom"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "nom"
-    assert argument.converters == [Choices]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "boom"
-    assert option.names == ["--boom"]
-    assert option.converters == [Choices]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_int_choices():
-    class Choices(int, enum.Enum):
-        Fooman = 321
-        Batman = 123
-        Bazman = 0
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            nat: typing.Annotated[annotations.Choices[Choices], "meow"],  # type: ignore
-            bag: typing.Annotated[annotations.Choices[Choices], "bagette"] = Choices.Bazman,  # type: ignore
-        ):
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
-            name="nat",
-            channel_types=None,
-            description="meow",
-            is_required=True,
-            choices=[
-                hikari.CommandChoice(name="Fooman", value=321),
-                hikari.CommandChoice(name="Batman", value=123),
-                hikari.CommandChoice(name="Bazman", value=0),
-            ],
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
-            name="bag",
-            channel_types=None,
-            description="bagette",
-            is_required=False,
-            choices=[
-                hikari.CommandChoice(name="Fooman", value=321),
-                hikari.CommandChoice(name="Batman", value=123),
-                hikari.CommandChoice(name="Bazman", value=0),
-            ],
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["nat"]
-    assert tracked_option.converters == [Choices]
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "nat"
-    assert tracked_option.name == "nat"
-    assert tracked_option.type is hikari.OptionType.INTEGER
-
-    tracked_option = callback._tracked_options["bag"]
-    assert tracked_option.converters == [Choices]
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bag"
-    assert tracked_option.name == "bag"
-    assert tracked_option.type is hikari.OptionType.INTEGER
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "nat"
-    assert argument.converters == [Choices]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "bag"
-    assert option.names == ["--bag"]
-    assert option.converters == [Choices]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_str_choices():
-    class Choices(str, enum.Enum):
-        Meow = "ok"
-        Bro = "no"
-        Sis = "pls"
-        Catgirl = "uwu"
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            ny: typing.Annotated[annotations.Choices[Choices], "fat"],  # type: ignore
-            aa: typing.Annotated[annotations.Choices[Choices], "bat"] = Choices.Sis,  # type: ignore
-        ):
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="ny",
-            channel_types=None,
-            description="fat",
-            is_required=True,
-            choices=[
-                hikari.CommandChoice(name="Meow", value="ok"),
-                hikari.CommandChoice(name="Bro", value="no"),
-                hikari.CommandChoice(name="Sis", value="pls"),
-                hikari.CommandChoice(name="Catgirl", value="uwu"),
-            ],
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="aa",
-            channel_types=None,
-            description="bat",
-            is_required=False,
-            choices=[
-                hikari.CommandChoice(name="Meow", value="ok"),
-                hikari.CommandChoice(name="Bro", value="no"),
-                hikari.CommandChoice(name="Sis", value="pls"),
-                hikari.CommandChoice(name="Catgirl", value="uwu"),
-            ],
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["ny"]
-    assert tracked_option.converters == [Choices]
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "ny"
-    assert tracked_option.name == "ny"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = callback._tracked_options["aa"]
-    assert tracked_option.converters == [Choices]
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "aa"
-    assert tracked_option.name == "aa"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "ny"
-    assert argument.converters == [Choices]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "aa"
-    assert option.names == ["--aa"]
-    assert option.converters == [Choices]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_choices_when_enum_has_no_other_base():
-    class Choices(enum.Enum):
-        ...
-
-    with pytest.warns(DeprecationWarning), pytest.raises(
-        TypeError, match="Enum must be a subclass of str, float or int"
-    ):
-        annotations.Choices[Choices]
-
-
-def test_with_generic_choices_when_enum_isnt_int_str_or_float():
-    class Choices(bytes, enum.Enum):
-        ...
-
-    with pytest.warns(DeprecationWarning), pytest.raises(
-        TypeError, match="Enum must be a subclass of str, float or int"
-    ):
-        annotations.Choices[Choices]
-
-
 def test_with_converted():
     mock_callback_1 = mock.Mock()
     mock_callback_2 = mock.Mock()
@@ -1189,168 +872,49 @@ async def command(
     assert option.max_value is None
 
 
-def test_with_generic_converted():
+def test_with_converted_type_miss_match():
     mock_callback_1 = mock.Mock()
-    mock_callback_2 = mock.Mock()
-    mock_callback_3 = mock.Mock()
 
+    with pytest.raises(
+        RuntimeError,
+        match=(
+            "Conflicting option types of <class 'hikari.messages.Attachment'> "
+            "and <class 'str'> found for 'boo' parameter"
+        ),
+    ):
+
+        @annotations.with_annotated_args(follow_wrapped=True)
+        @tanjun.as_message_command("nyaa")
+        async def _(
+            ctx: tanjun.abc.Context,
+            boo: typing.Annotated[annotations.Attachment, annotations.Converted(mock_callback_1)],
+        ) -> None:
+            ...
+
+
+def test_with_default():
     @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("nyaa", "meow")
-    @tanjun.as_message_command("nyaa")
+    @tanjun.as_slash_command("name", "description")
+    @tanjun.as_message_command("name")
     async def command(
-        ctx: tanjun.abc.Context,
-        boo: typing.Annotated[typing.Any, annotations.Converted(mock_callback_1, mock_callback_2), "description"],
-        bam: typing.Annotated[typing.Any, annotations.Converted(mock_callback_3), "nom"] = None,
+        ctx: tanjun.abc.Context, argument: typing.Annotated[annotations.Str, annotations.Default("nyaa"), "meow"]
     ) -> None:
         ...
 
     assert command.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="boo", channel_types=None, description="description", is_required=True
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="bam", channel_types=None, description="nom", is_required=False
-        ),
+            type=hikari.OptionType.STRING, name="argument", channel_types=None, description="meow", is_required=False
+        )
     ]
 
-    assert len(command._tracked_options) == 2
-    tracked_option = command._tracked_options["boo"]
-    assert tracked_option.converters == [mock_callback_1, mock_callback_2]
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "boo"
-    assert tracked_option.name == "boo"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = command._tracked_options["bam"]
-    assert tracked_option.converters == [mock_callback_3]
-    assert tracked_option.default is tanjun.abc.NO_PASS
+    assert len(command._tracked_options) == 1
+    tracked_option = command._tracked_options["argument"]
+    assert tracked_option.converters == []
+    assert tracked_option.default == "nyaa"
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bam"
-    assert tracked_option.name == "bam"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(command.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(command.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(command.wrapped_command.parser.arguments) == 1
-    argument = command.wrapped_command.parser.arguments[0]
-    assert argument.key == "boo"
-    assert argument.converters == [mock_callback_1, mock_callback_2]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(command.wrapped_command.parser.options) == 1
-    option = command.wrapped_command.parser.options[0]
-    assert option.key == "bam"
-    assert option.names == ["--bam"]
-    assert option.converters == [mock_callback_3]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_converted_type_miss_match():
-    mock_callback_1 = mock.Mock()
-
-    with pytest.raises(
-        RuntimeError,
-        match=(
-            "Conflicting option types of <class 'hikari.messages.Attachment'> "
-            "and <class 'str'> found for 'boo' parameter"
-        ),
-    ):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("nyaa")
-        async def _(
-            ctx: tanjun.abc.Context,
-            boo: typing.Annotated[annotations.Attachment, annotations.Converted(mock_callback_1)],
-        ) -> None:
-            ...
-
-
-def test_with_default():
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("name", "description")
-    @tanjun.as_message_command("name")
-    async def command(
-        ctx: tanjun.abc.Context, argument: typing.Annotated[annotations.Str, annotations.Default("nyaa"), "meow"]
-    ) -> None:
-        ...
-
-    assert command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="argument", channel_types=None, description="meow", is_required=False
-        )
-    ]
-
-    assert len(command._tracked_options) == 1
-    tracked_option = command._tracked_options["argument"]
-    assert tracked_option.converters == []
-    assert tracked_option.default == "nyaa"
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "argument"
-    assert tracked_option.name == "argument"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(command.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(command.wrapped_command.parser, tanjun.ShlexParser)
-    assert len(command.wrapped_command.parser.arguments) == 0
-    assert len(command.wrapped_command.parser.options) == 1
-    option = command.wrapped_command.parser.options[0]
-    assert option.key == "argument"
-    assert option.names == ["--argument"]
-    assert option.converters == []
-    assert option.default == "nyaa"
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_default():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("name", "description")
-        @tanjun.as_message_command("name")
-        async def command(
-            ctx: tanjun.abc.Context,
-            argument: typing.Annotated[
-                annotations.Default[annotations.Str, "nyaa"], "meow"  # noqa: F821  # type: ignore
-            ],
-        ) -> None:
-            ...
-
-    assert command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="argument", channel_types=None, description="meow", is_required=False
-        )
-    ]
-
-    assert len(command._tracked_options) == 1
-    tracked_option = command._tracked_options["argument"]
-    assert tracked_option.converters == []
-    assert tracked_option.default == "nyaa"
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "argument"
-    assert tracked_option.name == "argument"
+    assert tracked_option.key == "argument"
+    assert tracked_option.name == "argument"
     assert tracked_option.type is hikari.OptionType.STRING
 
     assert isinstance(command.wrapped_command, tanjun.MessageCommand)
@@ -1511,40 +1075,6 @@ async def callback(
     assert option.default is tanjun.abc.NO_PASS
 
 
-def test_with_flag_and_deprecated_default():
-    with pytest.warns(
-        DeprecationWarning, match=re.escape("Flag.__init__'s `default` argument is deprecated, use Default instead")
-    ):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("meow")
-        @tanjun.as_slash_command("beep", "boop")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            eep: typing.Annotated[
-                annotations.Int, annotations.Flag(default=1231), "b"  # pyright: ignore[reportDeprecated]
-            ] = 545454,
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-    assert len(callback.parser.arguments) == 0
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "eep"
-    assert option.default == 1231
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.INTEGER, name="eep", channel_types=None, description="b", is_required=False
-        )
-    ]
-    assert len(callback.wrapped_command._tracked_options) == 1
-    option = callback.wrapped_command._tracked_options["eep"]
-    assert option.default == 1231
-
-
 def test_with_flag_and_default():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_message_command("meow")
@@ -1627,41 +1157,6 @@ async def callback(
     assert option.default is tanjun.abc.NO_DEFAULT
 
 
-def test_with_generic_positional():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("name")
-        @tanjun.as_slash_command("boop", "description")
-        async def callback(
-            ctx: tanjun.abc.Context, beep: typing.Annotated[annotations.Positional[annotations.Str], "eat"]  # type: ignore
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-    assert len(callback.parser.arguments) == 1
-    assert len(callback.parser.options) == 0
-    option = callback.parser.arguments[0]
-    assert option.key == "beep"
-    assert option.converters == []
-    assert option.default is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="beep", channel_types=None, description="eat", is_required=True
-        )
-    ]
-    assert len(callback.wrapped_command._tracked_options) == 1
-    option = callback.wrapped_command._tracked_options["beep"]
-    assert option.default is tanjun.abc.NO_DEFAULT
-
-
 def test_with_greedy():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_message_command("command")
@@ -1682,28 +1177,6 @@ async def callback(ctx: tanjun.abc.Context, meep: typing.Annotated[annotations.I
     assert argument.max_value is None
 
 
-def test_with_generic_greedy():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        async def callback(ctx: tanjun.abc.Context, meep: annotations.Greedy[annotations.Str]):  # type: ignore
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "meep"
-    assert argument.converters == []
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is True
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-
 def test_with_length():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("name", "description")
@@ -1864,178 +1337,93 @@ async def callback(
     assert option.max_value is None
 
 
-def test_with_generic_length():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("name", "description")
-        @tanjun.as_message_command("name")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.Length[123], "nom"],  # type: ignore
-            other_value: typing.Annotated[typing.Optional[annotations.Length[5544]], "meow"] = None,  # type: ignore
-        ) -> None:
-            ...
+def test_with_int_max():
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        bee: typing.Annotated[annotations.Int, annotations.Max(543), "eee"],
+        yeet_no: typing.Annotated[typing.Union[annotations.Int, None], annotations.Max(543), "eep"] = None,
+    ):
+        ...
 
+    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
+    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
     assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="value",
+            type=hikari.OptionType.INTEGER,
+            name="bee",
             channel_types=None,
-            description="nom",
+            description="eee",
             is_required=True,
-            min_length=0,
-            max_length=123,
+            min_value=None,
+            max_value=543,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="other_value",
+            type=hikari.OptionType.INTEGER,
+            name="yeet_no",
             channel_types=None,
-            description="meow",
+            description="eep",
             is_required=False,
-            min_length=0,
-            max_length=5544,
+            min_value=None,
+            max_value=543,
         ),
     ]
 
     assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["value"]
+    tracked_option = callback._tracked_options["bee"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.STRING
+    assert tracked_option.key == "bee"
+    assert tracked_option.name == "bee"
+    assert tracked_option.type is hikari.OptionType.INTEGER
 
-    tracked_option = callback._tracked_options["other_value"]
+    tracked_option = callback._tracked_options["yeet_no"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_value"
-    assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
+    assert tracked_option.key == "yeet_no"
+    assert tracked_option.name == "yeet_no"
+    assert tracked_option.type is hikari.OptionType.INTEGER
 
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == []
+    assert argument.key == "bee"
+    assert argument.converters == [int]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
-    assert argument.min_length == 0
-    assert argument.max_length == 123
+    assert argument.min_length is None
+    assert argument.max_length is None
     assert argument.min_value is None
-    assert argument.max_value is None
+    assert argument.max_value == 543
 
     assert len(callback.wrapped_command.parser.options) == 1
     option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == []
+    assert option.key == "yeet_no"
+    assert option.names == ["--yeet-no"]
+    assert option.converters == [int]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
-    assert option.min_length == 0
-    assert option.max_length == 5544
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_length_when_min_specificed():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("name", "description")
-        @tanjun.as_message_command("name")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.Length[43, 5444], "nom"],  # type: ignore
-            other_value: typing.Annotated[typing.Optional[annotations.Length[32, 4343]], "meow"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="value",
-            channel_types=None,
-            description="nom",
-            is_required=True,
-            min_length=43,
-            max_length=5444,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="other_value",
-            channel_types=None,
-            description="meow",
-            is_required=False,
-            min_length=32,
-            max_length=4343,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = callback._tracked_options["other_value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_value"
-    assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == []
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length == 43
-    assert argument.max_length == 5444
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == []
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length == 32
-    assert option.max_length == 4343
+    assert option.min_length is None
+    assert option.max_length is None
     assert option.min_value is None
-    assert option.max_value is None
+    assert option.max_value == 543
 
 
-def test_with_int_max():
+def test_with_float_max():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("command", "description")
     @tanjun.as_message_command("command")
     async def callback(
         ctx: tanjun.abc.Context,
-        bee: typing.Annotated[annotations.Int, annotations.Max(543), "eee"],
-        yeet_no: typing.Annotated[typing.Union[annotations.Int, None], annotations.Max(543), "eep"] = None,
+        bee: typing.Annotated[annotations.Float, annotations.Max(234.432), "eee"],
+        yeet_no: typing.Annotated[typing.Union[annotations.Float, None], annotations.Max(234.432), "eep"] = None,
     ):
         ...
 
@@ -2043,22 +1431,22 @@ async def callback(
     assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
     assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
+            type=hikari.OptionType.FLOAT,
             name="bee",
             channel_types=None,
             description="eee",
             is_required=True,
             min_value=None,
-            max_value=543,
+            max_value=234.432,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
+            type=hikari.OptionType.FLOAT,
             name="yeet_no",
             channel_types=None,
             description="eep",
             is_required=False,
             min_value=None,
-            max_value=543,
+            max_value=234.432,
         ),
     ]
 
@@ -2066,56 +1454,68 @@ async def callback(
     tracked_option = callback._tracked_options["bee"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
+    assert tracked_option.is_always_float is True
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "bee"
     assert tracked_option.name == "bee"
-    assert tracked_option.type is hikari.OptionType.INTEGER
+    assert tracked_option.type is hikari.OptionType.FLOAT
 
     tracked_option = callback._tracked_options["yeet_no"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
+    assert tracked_option.is_always_float is True
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "yeet_no"
     assert tracked_option.name == "yeet_no"
-    assert tracked_option.type is hikari.OptionType.INTEGER
+    assert tracked_option.type is hikari.OptionType.FLOAT
 
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
     assert argument.key == "bee"
-    assert argument.converters == [int]
+    assert argument.converters == [float]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
     assert argument.min_length is None
     assert argument.max_length is None
     assert argument.min_value is None
-    assert argument.max_value == 543
+    assert argument.max_value == 234.432
 
     assert len(callback.wrapped_command.parser.options) == 1
     option = callback.wrapped_command.parser.options[0]
     assert option.key == "yeet_no"
     assert option.names == ["--yeet-no"]
-    assert option.converters == [int]
+    assert option.converters == [float]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
     assert option.min_length is None
     assert option.max_length is None
     assert option.min_value is None
-    assert option.max_value == 543
+    assert option.max_value == 234.432
 
 
-def test_with_float_max():
+def test_with_max_when_float_for_int():
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context, value: typing.Annotated[annotations.Int, annotations.Max(123.312), "description"]
+    ) -> None:
+        ...
+
+    with pytest.raises(TypeError, match="Max value of type float is not valid for a int argument"):
+        annotations.parse_annotated_args(callback, follow_wrapped=True)
+
+
+def test_with_max_when_int_for_float():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("command", "description")
     @tanjun.as_message_command("command")
     async def callback(
         ctx: tanjun.abc.Context,
-        bee: typing.Annotated[annotations.Float, annotations.Max(234.432), "eee"],
-        yeet_no: typing.Annotated[typing.Union[annotations.Float, None], annotations.Max(234.432), "eep"] = None,
-    ):
+        value: typing.Annotated[annotations.Float, annotations.Max(432), "description"],
+        other_value: typing.Annotated[typing.Union[annotations.Float, bool], annotations.Max(5431), "meow"] = False,
+    ) -> None:
         ...
 
     assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
@@ -2123,46 +1523,46 @@ async def callback(
     assert callback.build().options == [
         hikari.CommandOption(
             type=hikari.OptionType.FLOAT,
-            name="bee",
+            name="value",
             channel_types=None,
-            description="eee",
+            description="description",
             is_required=True,
             min_value=None,
-            max_value=234.432,
+            max_value=432,
         ),
         hikari.CommandOption(
             type=hikari.OptionType.FLOAT,
-            name="yeet_no",
+            name="other_value",
             channel_types=None,
-            description="eep",
+            description="meow",
             is_required=False,
             min_value=None,
-            max_value=234.432,
+            max_value=5431,
         ),
     ]
 
     assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["bee"]
+    tracked_option = callback._tracked_options["value"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
     assert tracked_option.is_always_float is True
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bee"
-    assert tracked_option.name == "bee"
+    assert tracked_option.key == "value"
+    assert tracked_option.name == "value"
     assert tracked_option.type is hikari.OptionType.FLOAT
 
-    tracked_option = callback._tracked_options["yeet_no"]
+    tracked_option = callback._tracked_options["other_value"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
     assert tracked_option.is_always_float is True
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "yeet_no"
-    assert tracked_option.name == "yeet_no"
+    assert tracked_option.key == "other_value"
+    assert tracked_option.name == "other_value"
     assert tracked_option.type is hikari.OptionType.FLOAT
 
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "bee"
+    assert argument.key == "value"
     assert argument.converters == [float]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
@@ -2170,12 +1570,12 @@ async def callback(
     assert argument.min_length is None
     assert argument.max_length is None
     assert argument.min_value is None
-    assert argument.max_value == 234.432
+    assert argument.max_value == 432
 
     assert len(callback.wrapped_command.parser.options) == 1
     option = callback.wrapped_command.parser.options[0]
-    assert option.key == "yeet_no"
-    assert option.names == ["--yeet-no"]
+    assert option.key == "other_value"
+    assert option.names == ["--other-value"]
     assert option.converters == [float]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
@@ -2183,27 +1583,31 @@ async def callback(
     assert option.min_length is None
     assert option.max_length is None
     assert option.min_value is None
-    assert option.max_value == 234.432
+    assert option.max_value == 5431
 
 
 @pytest.mark.parametrize(
-    ("value", "converter", "option_type"),
-    [(543, int, hikari.OptionType.INTEGER), (234.432, float, hikari.OptionType.FLOAT)],
+    ("type_", "raw_type", "option_type", "value"),
+    [
+        (annotations.Int, int, hikari.OptionType.INTEGER, 123),
+        (annotations.Float, float, hikari.OptionType.FLOAT, 321.123),
+    ],
 )
-def test_with_generic_max(
-    value: typing.Union[int, float], converter: typing.Union[type[int], type[float]], option_type: hikari.OptionType
+def test_with_min(
+    type_: type[typing.Union[int, float]],
+    raw_type: type[typing.Union[int, float]],
+    option_type: hikari.OptionType,
+    value: typing.Union[int, float],
 ):
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            number: typing.Annotated[annotations.Max[value], "eee"],  # type: ignore
-            other_number: typing.Annotated[annotations.Max[value], "eep"] = 54234,  # type: ignore
-        ):
-            ...
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        number: typing.Annotated[type_, annotations.Max(value), "eee"],
+        other_number: typing.Annotated[type_, annotations.Max(value), "eep"] = 54234,
+    ):
+        ...
 
     assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
     assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
@@ -2232,7 +1636,7 @@ async def callback(
     tracked_option = callback._tracked_options["number"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (converter is float)
+    assert tracked_option.is_always_float is (raw_type is float)
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "number"
     assert tracked_option.name == "number"
@@ -2241,7 +1645,7 @@ async def callback(
     tracked_option = callback._tracked_options["other_number"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (converter is float)
+    assert tracked_option.is_always_float is (raw_type is float)
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "other_number"
     assert tracked_option.name == "other_number"
@@ -2250,7 +1654,7 @@ async def callback(
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
     assert argument.key == "number"
-    assert argument.converters == [converter]
+    assert argument.converters == [raw_type]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
@@ -2263,7 +1667,7 @@ async def callback(
     option = callback.wrapped_command.parser.options[0]
     assert option.key == "other_number"
     assert option.names == ["--other-number"]
-    assert option.converters == [converter]
+    assert option.converters == [raw_type]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
@@ -2273,26 +1677,26 @@ async def callback(
     assert option.max_value == value
 
 
-def test_with_max_when_float_for_int():
+def test_with_min_when_float_for_int():
     @tanjun.as_slash_command("command", "description")
     @tanjun.as_message_command("command")
     async def callback(
-        ctx: tanjun.abc.Context, value: typing.Annotated[annotations.Int, annotations.Max(123.312), "description"]
+        ctx: tanjun.abc.Context, value: typing.Annotated[annotations.Int, annotations.Min(234.432), "description"]
     ) -> None:
         ...
 
-    with pytest.raises(TypeError, match="Max value of type float is not valid for a int argument"):
+    with pytest.raises(TypeError, match="Min value of type float is not valid for a int argument"):
         annotations.parse_annotated_args(callback, follow_wrapped=True)
 
 
-def test_with_max_when_int_for_float():
+def test_with_min_when_int_for_float():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("command", "description")
     @tanjun.as_message_command("command")
     async def callback(
         ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Float, annotations.Max(432), "description"],
-        other_value: typing.Annotated[typing.Union[annotations.Float, bool], annotations.Max(5431), "meow"] = False,
+        value: typing.Annotated[annotations.Float, annotations.Min(12333), "description"],
+        other_value: typing.Annotated[typing.Union[annotations.Float, bool], annotations.Min(44444), "meow"] = False,
     ) -> None:
         ...
 
@@ -2305,8 +1709,8 @@ async def callback(
             channel_types=None,
             description="description",
             is_required=True,
-            min_value=None,
-            max_value=432,
+            min_value=12333,
+            max_value=None,
         ),
         hikari.CommandOption(
             type=hikari.OptionType.FLOAT,
@@ -2314,8 +1718,8 @@ async def callback(
             channel_types=None,
             description="meow",
             is_required=False,
-            min_value=None,
-            max_value=5431,
+            min_value=44444,
+            max_value=None,
         ),
     ]
 
@@ -2347,8 +1751,8 @@ async def callback(
     assert argument.is_multi is False
     assert argument.min_length is None
     assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value == 432
+    assert argument.min_value == 12333
+    assert argument.max_value is None
 
     assert len(callback.wrapped_command.parser.options) == 1
     option = callback.wrapped_command.parser.options[0]
@@ -2360,30 +1764,18 @@ async def callback(
     assert option.is_multi is False
     assert option.min_length is None
     assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value == 5431
+    assert option.min_value == 44444
+    assert option.max_value is None
 
 
-@pytest.mark.parametrize(
-    ("type_", "raw_type", "option_type", "value"),
-    [
-        (annotations.Int, int, hikari.OptionType.INTEGER, 123),
-        (annotations.Float, float, hikari.OptionType.FLOAT, 321.123),
-    ],
-)
-def test_with_min(
-    type_: type[typing.Union[int, float]],
-    raw_type: type[typing.Union[int, float]],
-    option_type: hikari.OptionType,
-    value: typing.Union[int, float],
-):
+def test_with_overridden_name():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("command", "description")
     @tanjun.as_message_command("command")
     async def callback(
         ctx: tanjun.abc.Context,
-        number: typing.Annotated[type_, annotations.Max(value), "eee"],
-        other_number: typing.Annotated[type_, annotations.Max(value), "eep"] = 54234,
+        nyaa: typing.Annotated[annotations.Int, annotations.Name("boop"), "Nope"],
+        meow: typing.Annotated[annotations.Str, annotations.Name("meep_meep"), "Description"] = "meowow",
     ):
         ...
 
@@ -2391,284 +1783,27 @@ async def callback(
     assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
     assert callback.build().options == [
         hikari.CommandOption(
-            type=option_type,
-            name="number",
+            type=hikari.OptionType.INTEGER,
+            name="boop",
             channel_types=None,
-            description="eee",
+            description="Nope",
             is_required=True,
             min_value=None,
-            max_value=value,
+            max_value=None,
         ),
         hikari.CommandOption(
-            type=option_type,
-            name="other_number",
+            type=hikari.OptionType.STRING,
+            name="meep_meep",
             channel_types=None,
-            description="eep",
+            description="Description",
             is_required=False,
             min_value=None,
-            max_value=value,
+            max_value=None,
         ),
     ]
 
     assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (raw_type is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "number"
-    assert tracked_option.name == "number"
-    assert tracked_option.type is option_type
-
-    tracked_option = callback._tracked_options["other_number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (raw_type is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_number"
-    assert tracked_option.name == "other_number"
-    assert tracked_option.type is option_type
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "number"
-    assert argument.converters == [raw_type]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value == value
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_number"
-    assert option.names == ["--other-number"]
-    assert option.converters == [raw_type]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value == value
-
-
-@pytest.mark.parametrize(
-    ("value", "converter", "option_type"),
-    [(123, int, hikari.OptionType.INTEGER), (123.321, float, hikari.OptionType.FLOAT)],
-)
-def test_with_generic_min(
-    value: typing.Union[int, float], converter: typing.Union[type[int], type[float]], option_type: hikari.OptionType
-):
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            number: typing.Annotated[annotations.Min[value], "bee"],  # type: ignore
-            other_number: typing.Annotated[annotations.Min[value], "buzz"] = 321,  # type: ignore
-        ):
-            ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=option_type,
-            name="number",
-            channel_types=None,
-            description="bee",
-            is_required=True,
-            min_value=value,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=option_type,
-            name="other_number",
-            channel_types=None,
-            description="buzz",
-            is_required=False,
-            min_value=value,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (converter is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "number"
-    assert tracked_option.name == "number"
-    assert tracked_option.type is option_type
-
-    tracked_option = callback._tracked_options["other_number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (converter is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_number"
-    assert tracked_option.name == "other_number"
-    assert tracked_option.type is option_type
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "number"
-    assert argument.converters == [converter]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value == value
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_number"
-    assert option.names == ["--other-number"]
-    assert option.converters == [converter]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value == value
-    assert option.max_value is None
-
-
-def test_with_min_when_float_for_int():
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context, value: typing.Annotated[annotations.Int, annotations.Min(234.432), "description"]
-    ) -> None:
-        ...
-
-    with pytest.raises(TypeError, match="Min value of type float is not valid for a int argument"):
-        annotations.parse_annotated_args(callback, follow_wrapped=True)
-
-
-def test_with_min_when_int_for_float():
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Float, annotations.Min(12333), "description"],
-        other_value: typing.Annotated[typing.Union[annotations.Float, bool], annotations.Min(44444), "meow"] = False,
-    ) -> None:
-        ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
-            name="value",
-            channel_types=None,
-            description="description",
-            is_required=True,
-            min_value=12333,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
-            name="other_value",
-            channel_types=None,
-            description="meow",
-            is_required=False,
-            min_value=44444,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is True
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    tracked_option = callback._tracked_options["other_value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is True
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_value"
-    assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [float]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value == 12333
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == [float]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value == 44444
-    assert option.max_value is None
-
-
-def test_with_overridden_name():
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        nyaa: typing.Annotated[annotations.Int, annotations.Name("boop"), "Nope"],
-        meow: typing.Annotated[annotations.Str, annotations.Name("meep_meep"), "Description"] = "meowow",
-    ):
-        ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
-            name="boop",
-            channel_types=None,
-            description="Nope",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="meep_meep",
-            channel_types=None,
-            description="Description",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["boop"]
+    tracked_option = callback._tracked_options["boop"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
     assert tracked_option.is_always_float is False
@@ -2982,443 +2117,18 @@ async def callback(
     assert option.max_value == 6524.32
 
 
-@pytest.mark.parametrize(
-    ("min_value", "max_value", "converter", "option_type"),
-    [
-        (123.132, 321, float, hikari.OptionType.FLOAT),
-        (123, 321, int, hikari.OptionType.INTEGER),
-        (431, 1232.321, float, hikari.OptionType.FLOAT),
-        (452.432, 55234.2134, float, hikari.OptionType.FLOAT),
-    ],
-)
-def test_with_generic_ranged(
-    min_value: typing.Union[float, int],
-    max_value: typing.Union[float, int],
-    converter: typing.Union[type[float], type[int]],
-    option_type: hikari.OptionType,
-):
-    with pytest.warns(DeprecationWarning):
+def test_with_snowflake_or():
+    mock_callback = mock.Mock()
 
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            number: typing.Annotated[annotations.Ranged[min_value, max_value], "meow"],  # type: ignore
-            other_number: typing.Annotated[annotations.Ranged[min_value, max_value], "nom"] = 443,  # type: ignore
-        ):
-            ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=option_type,
-            name="number",
-            channel_types=None,
-            description="meow",
-            is_required=True,
-            min_value=min_value,
-            max_value=max_value,
-        ),
-        hikari.CommandOption(
-            type=option_type,
-            name="other_number",
-            channel_types=None,
-            description="nom",
-            is_required=False,
-            min_value=min_value,
-            max_value=max_value,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (converter is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "number"
-    assert tracked_option.name == "number"
-    assert tracked_option.type is option_type
-
-    tracked_option = callback._tracked_options["other_number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (converter is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_number"
-    assert tracked_option.name == "other_number"
-    assert tracked_option.type is option_type
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "number"
-    assert argument.converters == [converter]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value == min_value
-    assert argument.max_value == max_value
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_number"
-    assert option.names == ["--other-number"]
-    assert option.converters == [converter]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value == min_value
-    assert option.max_value == max_value
-
-
-def test_with_snowflake_or():
-    mock_callback = mock.Mock()
-
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_message_command("command")
-    @tanjun.as_slash_command("yeet", "description")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Role, annotations.SnowflakeOr(parse_id=mock_callback), "se"],
-        value_2: typing.Annotated[typing.Optional[annotations.User], annotations.SnowflakeOr(), "x"] = None,
-    ) -> None:
-        ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.ROLE,
-            name="value",
-            channel_types=None,
-            description="se",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.USER,
-            name="value_2",
-            channel_types=None,
-            description="x",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.ROLE
-
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.USER
-
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [mock_callback]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_snowflake]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_snowflake_or_for_channel():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Channel], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.Channel]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.CHANNEL,
-            name="value",
-            channel_types=None,
-            description="se",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.CHANNEL,
-            name="value_2",
-            channel_types=None,
-            description="x",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.CHANNEL
-
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.CHANNEL
-
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_channel_id]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_channel_id]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_snowflake_or_for_member():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Member], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.Member]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.USER,
-            name="value",
-            channel_types=None,
-            description="se",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.USER,
-            name="value_2",
-            channel_types=None,
-            description="x",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is True
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.USER
-
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is True
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.USER
-
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_user_id]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_user_id]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_snowflake_or_for_mentionable():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Mentionable], "se"],  # type: ignore
-            value_2: typing.Annotated[
-                typing.Optional[annotations.SnowflakeOr[annotations.Mentionable]], "x"  # type: ignore
-            ] = None,
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.MENTIONABLE,
-            name="value",
-            channel_types=None,
-            description="se",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.MENTIONABLE,
-            name="value_2",
-            channel_types=None,
-            description="x",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.MENTIONABLE
-
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.MENTIONABLE
-
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_snowflake]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_snowflake]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_snowflake_or_for_role():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Role], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.Role]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_message_command("command")
+    @tanjun.as_slash_command("yeet", "description")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        value: typing.Annotated[annotations.Role, annotations.SnowflakeOr(parse_id=mock_callback), "se"],
+        value_2: typing.Annotated[typing.Optional[annotations.User], annotations.SnowflakeOr(), "x"] = None,
+    ) -> None:
+        ...
 
     assert isinstance(callback.parser, tanjun.ShlexParser)
     assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
@@ -3433,88 +2143,6 @@ async def callback(
             min_value=None,
             max_value=None,
         ),
-        hikari.CommandOption(
-            type=hikari.OptionType.ROLE,
-            name="value_2",
-            channel_types=None,
-            description="x",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.ROLE
-
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.ROLE
-
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_role_id]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_role_id]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_snowflake_or_for_user():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.User], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.User]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.USER,
-            name="value",
-            channel_types=None,
-            description="se",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
         hikari.CommandOption(
             type=hikari.OptionType.USER,
             name="value_2",
@@ -3534,7 +2162,7 @@ async def callback(
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "value"
     assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.USER
+    assert tracked_option.type is hikari.OptionType.ROLE
 
     tracked_option = callback.wrapped_command._tracked_options["value_2"]
     assert tracked_option.converters == []
@@ -3548,89 +2176,7 @@ async def callback(
     assert len(callback.parser.arguments) == 1
     argument = callback.parser.arguments[0]
     assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_user_id]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_user_id]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_snowflake_or():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Bool], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.Bool]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.BOOLEAN,
-            name="value",
-            channel_types=None,
-            description="se",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.BOOLEAN,
-            name="value_2",
-            channel_types=None,
-            description="x",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.BOOLEAN
-
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.BOOLEAN
-
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [tanjun.to_bool]
+    assert argument.converters == [mock_callback]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
@@ -3643,7 +2189,7 @@ async def callback(
     option = callback.parser.options[0]
     assert option.key == "value_2"
     assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.to_bool]
+    assert option.converters == [tanjun.conversion.parse_snowflake]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
@@ -3773,113 +2319,6 @@ async def command(
     assert option.max_value is None
 
 
-def test_with_generic_these_channels():  # noqa: CFQ001
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("name", "description")
-        @tanjun.as_message_command("name")
-        async def command(
-            ctx: tanjun.abc.Context,
-            bb: typing.Annotated[annotations.TheseChannels[hikari.GuildChannel], "nep"],  # type: ignore
-            bat: typing.Annotated[
-                typing.Optional[annotations.TheseChannels[hikari.GuildVoiceChannel, hikari.PrivateChannel]], "bip"  # type: ignore
-            ] = None,
-        ):
-            ...
-
-    expected_types_1 = {
-        hikari.ChannelType.GUILD_CATEGORY,
-        hikari.ChannelType.GUILD_NEWS,
-        hikari.ChannelType.GUILD_NEWS_THREAD,
-        hikari.ChannelType.GUILD_PRIVATE_THREAD,
-        hikari.ChannelType.GUILD_PUBLIC_THREAD,
-        hikari.ChannelType.GUILD_STAGE,
-        hikari.ChannelType.GUILD_TEXT,
-        hikari.ChannelType.GUILD_VOICE,
-        hikari.ChannelType.GUILD_FORUM,
-    }
-    expected_types_2 = {hikari.ChannelType.DM, hikari.ChannelType.GROUP_DM, hikari.ChannelType.GUILD_VOICE}
-
-    assert isinstance(command.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(command.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(command.build().options) == 2
-    option = command.build().options[0]
-    assert option.type is hikari.OptionType.CHANNEL
-    assert option.name == "bb"
-    assert option.description == "nep"
-    assert option.is_required is True
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-    assert option.channel_types
-    assert len(option.channel_types) == 9
-    assert set(option.channel_types) == expected_types_1
-
-    option = command.build().options[1]
-    assert option.type is hikari.OptionType.CHANNEL
-    assert option.name == "bat"
-    assert option.description == "bip"
-    assert option.is_required is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-    assert option.channel_types
-    assert len(option.channel_types) == 3
-    assert set(option.channel_types) == expected_types_2
-
-    assert len(command._tracked_options) == 2
-    tracked_option = command._tracked_options["bb"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bb"
-    assert tracked_option.name == "bb"
-    assert tracked_option.type is hikari.OptionType.CHANNEL
-
-    tracked_option = command._tracked_options["bat"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bat"
-    assert tracked_option.name == "bat"
-    assert tracked_option.type is hikari.OptionType.CHANNEL
-
-    assert len(command.wrapped_command.parser.arguments) == 1
-    argument = command.wrapped_command.parser.arguments[0]
-    assert argument.key == "bb"
-    assert len(argument.converters) == 1
-    assert isinstance(argument.converters[0], tanjun.conversion.ToChannel)
-    assert argument.converters[0]._allowed_types == expected_types_1
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(command.wrapped_command.parser.options) == 1
-    option = command.wrapped_command.parser.options[0]
-    assert option.key == "bat"
-    assert option.names == ["--bat"]
-    assert len(option.converters) == 1
-    assert isinstance(option.converters[0], tanjun.conversion.ToChannel)
-    assert option.converters[0]._allowed_types == expected_types_2
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
 def test_for_attachment_option():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("meow", "nom")
diff --git a/tests/test_annotations_future_annotations.py b/tests/test_annotations_future_annotations.py
index 2f8948a14..95f0582bf 100644
--- a/tests/test_annotations_future_annotations.py
+++ b/tests/test_annotations_future_annotations.py
@@ -30,9 +30,7 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 from __future__ import annotations as _
 
-import enum
 import inspect
-import re
 import sys
 import typing
 from collections import abc as collections
@@ -682,317 +680,6 @@ async def callback(
         annotations.with_annotated_args(callback)  # pyright: ignore[reportUnknownArgumentType]
 
 
-def test_with_generic_float_choices():
-    global Choices1
-
-    class Choices1(float, enum.Enum):
-        Foo = 123.321
-        Bar = 543.123
-        Blam = 432.123
-        Ok = 43.34
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            nom: typing.Annotated[annotations.Choices[Choices1], "description"],  # type: ignore
-            boom: typing.Annotated[annotations.Choices[Choices1], "bag"] = Choices1.Blam,  # type: ignore
-        ):
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
-            name="nom",
-            channel_types=None,
-            description="description",
-            is_required=True,
-            choices=[
-                hikari.CommandChoice(name="Foo", value=123.321),
-                hikari.CommandChoice(name="Bar", value=543.123),
-                hikari.CommandChoice(name="Blam", value=432.123),
-                hikari.CommandChoice(name="Ok", value=43.34),
-            ],
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
-            name="boom",
-            channel_types=None,
-            description="bag",
-            is_required=False,
-            choices=[
-                hikari.CommandChoice(name="Foo", value=123.321),
-                hikari.CommandChoice(name="Bar", value=543.123),
-                hikari.CommandChoice(name="Blam", value=432.123),
-                hikari.CommandChoice(name="Ok", value=43.34),
-            ],
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["nom"]
-    assert tracked_option.converters == [Choices1]
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is True
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "nom"
-    assert tracked_option.name == "nom"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    tracked_option = callback._tracked_options["boom"]
-    assert tracked_option.converters == [Choices1]
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is True
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "boom"
-    assert tracked_option.name == "boom"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "nom"
-    assert argument.converters == [Choices1]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "boom"
-    assert option.names == ["--boom"]
-    assert option.converters == [Choices1]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_int_choices():
-    global Choices2
-
-    class Choices2(int, enum.Enum):
-        Fooman = 321
-        Batman = 123
-        Bazman = 0
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            nat: typing.Annotated[annotations.Choices[Choices2], "meow"],  # type: ignore
-            bag: typing.Annotated[annotations.Choices[Choices2], "bagette"] = Choices2.Bazman,  # type: ignore
-        ):
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
-            name="nat",
-            channel_types=None,
-            description="meow",
-            is_required=True,
-            choices=[
-                hikari.CommandChoice(name="Fooman", value=321),
-                hikari.CommandChoice(name="Batman", value=123),
-                hikari.CommandChoice(name="Bazman", value=0),
-            ],
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
-            name="bag",
-            channel_types=None,
-            description="bagette",
-            is_required=False,
-            choices=[
-                hikari.CommandChoice(name="Fooman", value=321),
-                hikari.CommandChoice(name="Batman", value=123),
-                hikari.CommandChoice(name="Bazman", value=0),
-            ],
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["nat"]
-    assert tracked_option.converters == [Choices2]
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "nat"
-    assert tracked_option.name == "nat"
-    assert tracked_option.type is hikari.OptionType.INTEGER
-
-    tracked_option = callback._tracked_options["bag"]
-    assert tracked_option.converters == [Choices2]
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bag"
-    assert tracked_option.name == "bag"
-    assert tracked_option.type is hikari.OptionType.INTEGER
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "nat"
-    assert argument.converters == [Choices2]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "bag"
-    assert option.names == ["--bag"]
-    assert option.converters == [Choices2]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_str_choices():
-    global Choices3
-
-    class Choices3(str, enum.Enum):
-        Meow = "ok"
-        Bro = "no"
-        Sis = "pls"
-        Catgirl = "uwu"
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            ny: typing.Annotated[annotations.Choices[Choices3], "fat"],  # type: ignore
-            aa: typing.Annotated[annotations.Choices[Choices3], "bat"] = Choices3.Sis,  # type: ignore
-        ):
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="ny",
-            channel_types=None,
-            description="fat",
-            is_required=True,
-            choices=[
-                hikari.CommandChoice(name="Meow", value="ok"),
-                hikari.CommandChoice(name="Bro", value="no"),
-                hikari.CommandChoice(name="Sis", value="pls"),
-                hikari.CommandChoice(name="Catgirl", value="uwu"),
-            ],
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="aa",
-            channel_types=None,
-            description="bat",
-            is_required=False,
-            choices=[
-                hikari.CommandChoice(name="Meow", value="ok"),
-                hikari.CommandChoice(name="Bro", value="no"),
-                hikari.CommandChoice(name="Sis", value="pls"),
-                hikari.CommandChoice(name="Catgirl", value="uwu"),
-            ],
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["ny"]
-    assert tracked_option.converters == [Choices3]
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "ny"
-    assert tracked_option.name == "ny"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = callback._tracked_options["aa"]
-    assert tracked_option.converters == [Choices3]
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "aa"
-    assert tracked_option.name == "aa"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "ny"
-    assert argument.converters == [Choices3]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "aa"
-    assert option.names == ["--aa"]
-    assert option.converters == [Choices3]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_choices_when_enum_has_no_other_base():
-    class Choices(enum.Enum):
-        ...
-
-    with pytest.warns(DeprecationWarning), pytest.raises(
-        TypeError, match="Enum must be a subclass of str, float or int"
-    ):
-        annotations.Choices[Choices]
-
-
-def test_with_generic_choices_when_enum_isnt_int_str_or_float():
-    class Choices(bytes, enum.Enum):
-        ...
-
-    with pytest.warns(DeprecationWarning), pytest.raises(
-        TypeError, match="Enum must be a subclass of str, float or int"
-    ):
-        annotations.Choices[Choices]
-
-
 def test_with_converted():
     global mock_callback_1
     global mock_callback_2
@@ -1070,83 +757,6 @@ async def command(
     assert option.max_value is None
 
 
-def test_with_generic_converted():
-    global mock_callback_1
-    global mock_callback_2
-    global mock_callback_3
-    mock_callback_1 = mock.Mock()
-    mock_callback_2 = mock.Mock()
-    mock_callback_3 = mock.Mock()
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("nyaa", "meow")
-        @tanjun.as_message_command("nyaa")
-        async def command(
-            ctx: tanjun.abc.Context,
-            boo: typing.Annotated[annotations.Converted[mock_callback_1, mock_callback_2], "description"],  # type: ignore
-            bam: typing.Annotated[annotations.Converted[mock_callback_3], "nom"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="boo", channel_types=None, description="description", is_required=True
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="bam", channel_types=None, description="nom", is_required=False
-        ),
-    ]
-
-    assert len(command._tracked_options) == 2
-    tracked_option = command._tracked_options["boo"]
-    assert tracked_option.converters == [mock_callback_1, mock_callback_2]
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "boo"
-    assert tracked_option.name == "boo"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = command._tracked_options["bam"]
-    assert tracked_option.converters == [mock_callback_3]
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bam"
-    assert tracked_option.name == "bam"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(command.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(command.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(command.wrapped_command.parser.arguments) == 1
-    argument = command.wrapped_command.parser.arguments[0]
-    assert argument.key == "boo"
-    assert argument.converters == [mock_callback_1, mock_callback_2]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(command.wrapped_command.parser.options) == 1
-    option = command.wrapped_command.parser.options[0]
-    assert option.key == "bam"
-    assert option.names == ["--bam"]
-    assert option.converters == [mock_callback_3]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
 def test_with_default():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("name", "description")
@@ -1189,53 +799,6 @@ async def command(
     assert option.max_value is None
 
 
-def test_with_generic_default():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("name", "description")
-        @tanjun.as_message_command("name")
-        async def command(
-            ctx: tanjun.abc.Context,
-            argument: typing.Annotated[
-                annotations.Default[annotations.Str, "nyaa"], "meow"  # noqa: F821  # type: ignore
-            ],
-        ) -> None:
-            ...
-
-    assert command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="argument", channel_types=None, description="meow", is_required=False
-        )
-    ]
-
-    assert len(command._tracked_options) == 1
-    tracked_option = command._tracked_options["argument"]
-    assert tracked_option.converters == []
-    assert tracked_option.default == "nyaa"
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "argument"
-    assert tracked_option.name == "argument"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(command.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(command.wrapped_command.parser, tanjun.ShlexParser)
-    assert len(command.wrapped_command.parser.arguments) == 0
-    assert len(command.wrapped_command.parser.options) == 1
-    option = command.wrapped_command.parser.options[0]
-    assert option.key == "argument"
-    assert option.names == ["--argument"]
-    assert option.converters == []
-    assert option.default == "nyaa"
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
 def test_with_default_overriding_signature_default():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("name", "description")
@@ -1378,40 +941,6 @@ async def callback(
     assert option.default is tanjun.abc.NO_PASS
 
 
-def test_with_flag_and_deprecated_default():
-    with pytest.warns(
-        DeprecationWarning, match=re.escape("Flag.__init__'s `default` argument is deprecated, use Default instead")
-    ):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("meow")
-        @tanjun.as_slash_command("beep", "boop")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            eep: typing.Annotated[
-                annotations.Int, annotations.Flag(default=1231), "b"  # pyright: ignore[reportDeprecated]
-            ] = 545454,
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-    assert len(callback.parser.arguments) == 0
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "eep"
-    assert option.default == 1231
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.INTEGER, name="eep", channel_types=None, description="b", is_required=False
-        )
-    ]
-    assert len(callback.wrapped_command._tracked_options) == 1
-    option = callback.wrapped_command._tracked_options["eep"]
-    assert option.default == 1231
-
-
 def test_with_flag_and_default():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_message_command("meow")
@@ -1486,921 +1015,63 @@ async def callback(
 
     assert callback.wrapped_command.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="beep", channel_types=None, description="eat", is_required=True
-        )
-    ]
-    assert len(callback.wrapped_command._tracked_options) == 1
-    option = callback.wrapped_command._tracked_options["beep"]
-    assert option.default is tanjun.abc.NO_DEFAULT
-
-
-def test_with_generic_positional():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("name")
-        @tanjun.as_slash_command("boop", "description")
-        async def callback(
-            ctx: tanjun.abc.Context, beep: typing.Annotated[annotations.Positional[annotations.Str], "eat"]  # type: ignore
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-    assert len(callback.parser.arguments) == 1
-    assert len(callback.parser.options) == 0
-    option = callback.parser.arguments[0]
-    assert option.key == "beep"
-    assert option.converters == []
-    assert option.default is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING, name="beep", channel_types=None, description="eat", is_required=True
-        )
-    ]
-    assert len(callback.wrapped_command._tracked_options) == 1
-    option = callback.wrapped_command._tracked_options["beep"]
-    assert option.default is tanjun.abc.NO_DEFAULT
-
-
-def test_with_greedy():
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_message_command("command")
-    async def callback(ctx: tanjun.abc.Context, meep: typing.Annotated[annotations.Int, annotations.Greedy()]):
-        ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "meep"
-    assert argument.converters == [int]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is True
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-
-def test_with_generic_greedy():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        async def callback(ctx: tanjun.abc.Context, meep: annotations.Greedy[annotations.Str]):  # type: ignore
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "meep"
-    assert argument.converters == []
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is True
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-
-def test_with_length():
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("name", "description")
-    @tanjun.as_message_command("name")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Str, annotations.Length(123), "nom"],
-        other_value: typing.Annotated[typing.Optional[annotations.Str], annotations.Length(5544), "meow"] = None,
-    ) -> None:
-        ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="value",
-            channel_types=None,
-            description="nom",
-            is_required=True,
-            min_length=0,
-            max_length=123,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="other_value",
-            channel_types=None,
-            description="meow",
-            is_required=False,
-            min_length=0,
-            max_length=5544,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = callback._tracked_options["other_value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_value"
-    assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == []
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length == 0
-    assert argument.max_length == 123
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == []
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length == 0
-    assert option.max_length == 5544
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_length_when_min_specificed():
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("name", "description")
-    @tanjun.as_message_command("name")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Str, annotations.Length(43, 5444), "nom"],
-        other_value: typing.Annotated[typing.Optional[annotations.Str], annotations.Length(32, 4343), "meow"] = None,
-    ) -> None:
-        ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="value",
-            channel_types=None,
-            description="nom",
-            is_required=True,
-            min_length=43,
-            max_length=5444,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="other_value",
-            channel_types=None,
-            description="meow",
-            is_required=False,
-            min_length=32,
-            max_length=4343,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = callback._tracked_options["other_value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_value"
-    assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == []
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length == 43
-    assert argument.max_length == 5444
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == []
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length == 32
-    assert option.max_length == 4343
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_length():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("name", "description")
-        @tanjun.as_message_command("name")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.Length[123], "nom"],  # type: ignore
-            other_value: typing.Annotated[typing.Optional[annotations.Length[5544]], "meow"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="value",
-            channel_types=None,
-            description="nom",
-            is_required=True,
-            min_length=0,
-            max_length=123,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="other_value",
-            channel_types=None,
-            description="meow",
-            is_required=False,
-            min_length=0,
-            max_length=5544,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = callback._tracked_options["other_value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_value"
-    assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == []
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length == 0
-    assert argument.max_length == 123
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == []
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length == 0
-    assert option.max_length == 5544
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-def test_with_generic_length_when_min_specificed():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("name", "description")
-        @tanjun.as_message_command("name")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.Length[43, 5444], "nom"],  # type: ignore
-            other_value: typing.Annotated[typing.Optional[annotations.Length[32, 4343]], "meow"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="value",
-            channel_types=None,
-            description="nom",
-            is_required=True,
-            min_length=43,
-            max_length=5444,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="other_value",
-            channel_types=None,
-            description="meow",
-            is_required=False,
-            min_length=32,
-            max_length=4343,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    tracked_option = callback._tracked_options["other_value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_value"
-    assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == []
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length == 43
-    assert argument.max_length == 5444
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == []
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length == 32
-    assert option.max_length == 4343
-    assert option.min_value is None
-    assert option.max_value is None
-
-
-@pytest.mark.parametrize(
-    ("type_", "value", "raw_type", "option_type"),
-    [
-        (annotations.Int, 543, int, hikari.OptionType.INTEGER),
-        (annotations.Float, 234.432, float, hikari.OptionType.FLOAT),
-    ],
-)
-def test_with_max(
-    type_: type[typing.Union[int, float]],
-    value: typing.Union[int, float],
-    raw_type: type[typing.Any],
-    option_type: hikari.OptionType,
-):
-    global type__
-    global value_
-    type__ = type_
-    value_ = value
-
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        bee: typing.Annotated[type__, annotations.Max(value_), "eee"],  # type: ignore
-        yeet_no: typing.Annotated[typing.Union[type__, None], annotations.Max(value_), "eep"] = None,  # type: ignore
-    ):
-        ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=option_type,
-            name="bee",
-            channel_types=None,
-            description="eee",
-            is_required=True,
-            min_value=None,
-            max_value=value,
-        ),
-        hikari.CommandOption(
-            type=option_type,
-            name="yeet_no",
-            channel_types=None,
-            description="eep",
-            is_required=False,
-            min_value=None,
-            max_value=value,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["bee"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (raw_type is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bee"
-    assert tracked_option.name == "bee"
-    assert tracked_option.type is option_type
-
-    tracked_option = callback._tracked_options["yeet_no"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (raw_type is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "yeet_no"
-    assert tracked_option.name == "yeet_no"
-    assert tracked_option.type is option_type
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "bee"
-    assert argument.converters == [raw_type]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value == value
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "yeet_no"
-    assert option.names == ["--yeet-no"]
-    assert option.converters == [raw_type]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value == value
-
-
-@pytest.mark.parametrize(
-    ("value", "converter", "option_type"),
-    [(543, int, hikari.OptionType.INTEGER), (234.432, float, hikari.OptionType.FLOAT)],
-)
-def test_with_generic_max(
-    value: typing.Union[int, float], converter: typing.Union[type[int], type[float]], option_type: hikari.OptionType
-):
-    global value_
-    value_ = value
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            number: typing.Annotated[annotations.Max[value_], "eee"],  # type: ignore
-            other_number: typing.Annotated[annotations.Max[value_], "eep"] = 54234,  # type: ignore
-        ):
-            ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=option_type,
-            name="number",
-            channel_types=None,
-            description="eee",
-            is_required=True,
-            min_value=None,
-            max_value=value,
-        ),
-        hikari.CommandOption(
-            type=option_type,
-            name="other_number",
-            channel_types=None,
-            description="eep",
-            is_required=False,
-            min_value=None,
-            max_value=value,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (converter is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "number"
-    assert tracked_option.name == "number"
-    assert tracked_option.type is option_type
-
-    tracked_option = callback._tracked_options["other_number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (converter is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_number"
-    assert tracked_option.name == "other_number"
-    assert tracked_option.type is option_type
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "number"
-    assert argument.converters == [converter]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value == value
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_number"
-    assert option.names == ["--other-number"]
-    assert option.converters == [converter]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value == value
-
-
-def test_with_max_when_float_for_int():
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context, value: typing.Annotated[annotations.Int, annotations.Max(123.312), "description"]
-    ) -> None:
-        ...
-
-    with pytest.raises(TypeError, match="Max value of type float is not valid for a int argument"):
-        annotations.with_annotated_args(follow_wrapped=True)(callback)
-
-
-def test_with_max_when_int_for_float():
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Float, annotations.Max(432), "description"],
-        other_value: typing.Annotated[typing.Union[annotations.Float, bool], annotations.Max(5431), "meow"] = False,
-    ) -> None:
-        ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
-            name="value",
-            channel_types=None,
-            description="description",
-            is_required=True,
-            min_value=None,
-            max_value=432,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
-            name="other_value",
-            channel_types=None,
-            description="meow",
-            is_required=False,
-            min_value=None,
-            max_value=5431,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is True
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    tracked_option = callback._tracked_options["other_value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is True
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_value"
-    assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [float]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value == 432
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == [float]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value == 5431
-
-
-@pytest.mark.parametrize(
-    ("type_", "raw_type", "option_type", "value"),
-    [
-        (annotations.Int, int, hikari.OptionType.INTEGER, 123),
-        (annotations.Float, float, hikari.OptionType.FLOAT, 321.123),
-    ],
-)
-def test_with_min(
-    type_: type[typing.Union[int, float]],
-    raw_type: type[typing.Union[int, float]],
-    option_type: hikari.OptionType,
-    value: typing.Union[int, float],
-):
-    global type__
-    global value_
-    type__ = type_
-    value_ = value
-
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        number: typing.Annotated[type__, annotations.Max(value_), "eee"],  # type: ignore
-        other_number: typing.Annotated[type__, annotations.Max(value_), "eep"] = 54234,  # type: ignore
-    ):
-        ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=option_type,
-            name="number",
-            channel_types=None,
-            description="eee",
-            is_required=True,
-            min_value=None,
-            max_value=value,
-        ),
-        hikari.CommandOption(
-            type=option_type,
-            name="other_number",
-            channel_types=None,
-            description="eep",
-            is_required=False,
-            min_value=None,
-            max_value=value,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (raw_type is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "number"
-    assert tracked_option.name == "number"
-    assert tracked_option.type is option_type
-
-    tracked_option = callback._tracked_options["other_number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (raw_type is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_number"
-    assert tracked_option.name == "other_number"
-    assert tracked_option.type is option_type
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "number"
-    assert argument.converters == [raw_type]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value == value
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_number"
-    assert option.names == ["--other-number"]
-    assert option.converters == [raw_type]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value == value
-
-
-@pytest.mark.parametrize(
-    ("value", "converter", "option_type"),
-    [(123, int, hikari.OptionType.INTEGER), (123.321, float, hikari.OptionType.FLOAT)],
-)
-def test_with_generic_min(
-    value: typing.Union[int, float], converter: typing.Union[type[int], type[float]], option_type: hikari.OptionType
-):
-    global value_
-    value_ = value
-
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            number: typing.Annotated[annotations.Min[value_], "bee"],  # type: ignore
-            other_number: typing.Annotated[annotations.Min[value_], "buzz"] = 321,  # type: ignore
-        ):
-            ...
-
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=option_type,
-            name="number",
-            channel_types=None,
-            description="bee",
-            is_required=True,
-            min_value=value,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=option_type,
-            name="other_number",
-            channel_types=None,
-            description="buzz",
-            is_required=False,
-            min_value=value,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (converter is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "number"
-    assert tracked_option.name == "number"
-    assert tracked_option.type is option_type
-
-    tracked_option = callback._tracked_options["other_number"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (converter is float)
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "other_number"
-    assert tracked_option.name == "other_number"
-    assert tracked_option.type is option_type
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "number"
-    assert argument.converters == [converter]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value == value
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_number"
-    assert option.names == ["--other-number"]
-    assert option.converters == [converter]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value == value
-    assert option.max_value is None
+            type=hikari.OptionType.STRING, name="beep", channel_types=None, description="eat", is_required=True
+        )
+    ]
+    assert len(callback.wrapped_command._tracked_options) == 1
+    option = callback.wrapped_command._tracked_options["beep"]
+    assert option.default is tanjun.abc.NO_DEFAULT
 
 
-def test_with_min_when_float_for_int():
-    @tanjun.as_slash_command("command", "description")
+def test_with_greedy():
+    @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context, value: typing.Annotated[annotations.Int, annotations.Min(234.432), "description"]
-    ) -> None:
+    async def callback(ctx: tanjun.abc.Context, meep: typing.Annotated[annotations.Int, annotations.Greedy()]):
         ...
 
-    with pytest.raises(TypeError, match="Min value of type float is not valid for a int argument"):
-        annotations.with_annotated_args(follow_wrapped=True)(callback)
+    assert isinstance(callback.parser, tanjun.ShlexParser)
+    assert len(callback.parser.arguments) == 1
+    argument = callback.parser.arguments[0]
+    assert argument.key == "meep"
+    assert argument.converters == [int]
+    assert argument.default is tanjun.abc.NO_DEFAULT
+    assert argument.is_greedy is True
+    assert argument.is_multi is False
+    assert argument.min_length is None
+    assert argument.max_length is None
+    assert argument.min_value is None
+    assert argument.max_value is None
 
 
-def test_with_min_when_int_for_float():
+def test_with_length():
     @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
+    @tanjun.as_slash_command("name", "description")
+    @tanjun.as_message_command("name")
     async def callback(
         ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Float, annotations.Min(12333), "description"],
-        other_value: typing.Annotated[typing.Union[annotations.Float, bool], annotations.Min(44444), "meow"] = False,
+        value: typing.Annotated[annotations.Str, annotations.Length(123), "nom"],
+        other_value: typing.Annotated[typing.Optional[annotations.Str], annotations.Length(5544), "meow"] = None,
     ) -> None:
         ...
 
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
     assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
+            type=hikari.OptionType.STRING,
             name="value",
             channel_types=None,
-            description="description",
+            description="nom",
             is_required=True,
-            min_value=12333,
-            max_value=None,
+            min_length=0,
+            max_length=123,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.FLOAT,
+            type=hikari.OptionType.STRING,
             name="other_value",
             channel_types=None,
             description="meow",
             is_required=False,
-            min_value=44444,
-            max_value=None,
+            min_length=0,
+            max_length=5544,
         ),
     ]
 
@@ -2408,215 +1079,155 @@ async def callback(
     tracked_option = callback._tracked_options["value"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is True
+    assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "value"
     assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.FLOAT
+    assert tracked_option.type is hikari.OptionType.STRING
 
     tracked_option = callback._tracked_options["other_value"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is True
+    assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "other_value"
     assert tracked_option.name == "other_value"
-    assert tracked_option.type is hikari.OptionType.FLOAT
-
-    assert len(callback.wrapped_command.parser.arguments) == 1
-    argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [float]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value == 12333
-    assert argument.max_value is None
-
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_value"
-    assert option.names == ["--other-value"]
-    assert option.converters == [float]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value == 44444
-    assert option.max_value is None
-
-
-def test_with_overridden_name():
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        nyaa: typing.Annotated[annotations.Int, annotations.Name("boop"), "Nope"],
-        meow: typing.Annotated[annotations.Str, annotations.Name("meep_meep"), "Description"] = "meowow",
-    ):
-        ...
+    assert tracked_option.type is hikari.OptionType.STRING
 
     assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
     assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
-            name="boop",
-            channel_types=None,
-            description="Nope",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="meep_meep",
-            channel_types=None,
-            description="Description",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["boop"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "nyaa"
-    assert tracked_option.name == "boop"
-    assert tracked_option.type is hikari.OptionType.INTEGER
-
-    tracked_option = callback._tracked_options["meep_meep"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "meow"
-    assert tracked_option.name == "meep_meep"
-    assert tracked_option.type is hikari.OptionType.STRING
 
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "nyaa"
-    assert argument.converters == [int]
+    assert argument.key == "value"
+    assert argument.converters == []
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
+    assert argument.min_length == 0
+    assert argument.max_length == 123
     assert argument.min_value is None
     assert argument.max_value is None
 
     assert len(callback.wrapped_command.parser.options) == 1
     option = callback.wrapped_command.parser.options[0]
-    assert option.key == "meow"
-    assert option.names == ["--meep-meep"]
+    assert option.key == "other_value"
+    assert option.names == ["--other-value"]
     assert option.converters == []
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
+    assert option.min_length == 0
+    assert option.max_length == 5544
     assert option.min_value is None
     assert option.max_value is None
 
 
-def test_with_individually_overridden_name():
+def test_with_length_when_min_specificed():
     @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_slash_command("command", "description")
-    @tanjun.as_message_command("command")
+    @tanjun.as_slash_command("name", "description")
+    @tanjun.as_message_command("name")
     async def callback(
         ctx: tanjun.abc.Context,
-        nyaa: typing.Annotated[annotations.Int, annotations.Name("nom", slash="oop"), "Nope"],
-        meow: typing.Annotated[
-            annotations.Str, annotations.Name("nom2", slash="n", message="--boop-oop"), "Description"
-        ] = "meowow",
-    ):
+        value: typing.Annotated[annotations.Str, annotations.Length(43, 5444), "nom"],
+        other_value: typing.Annotated[typing.Optional[annotations.Str], annotations.Length(32, 4343), "meow"] = None,
+    ) -> None:
         ...
 
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
     assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
-            name="oop",
+            type=hikari.OptionType.STRING,
+            name="value",
             channel_types=None,
-            description="Nope",
+            description="nom",
             is_required=True,
-            min_value=None,
-            max_value=None,
+            min_length=43,
+            max_length=5444,
         ),
         hikari.CommandOption(
             type=hikari.OptionType.STRING,
-            name="n",
+            name="other_value",
             channel_types=None,
-            description="Description",
+            description="meow",
             is_required=False,
-            min_value=None,
-            max_value=None,
+            min_length=32,
+            max_length=4343,
         ),
     ]
 
     assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["oop"]
+    tracked_option = callback._tracked_options["value"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "nyaa"
-    assert tracked_option.name == "oop"
-    assert tracked_option.type is hikari.OptionType.INTEGER
+    assert tracked_option.key == "value"
+    assert tracked_option.name == "value"
+    assert tracked_option.type is hikari.OptionType.STRING
 
-    tracked_option = callback._tracked_options["n"]
+    tracked_option = callback._tracked_options["other_value"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "meow"
-    assert tracked_option.name == "n"
+    assert tracked_option.key == "other_value"
+    assert tracked_option.name == "other_value"
     assert tracked_option.type is hikari.OptionType.STRING
 
+    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
+    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
+
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "nyaa"
-    assert argument.converters == [int]
+    assert argument.key == "value"
+    assert argument.converters == []
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
+    assert argument.min_length == 43
+    assert argument.max_length == 5444
     assert argument.min_value is None
     assert argument.max_value is None
 
     assert len(callback.wrapped_command.parser.options) == 1
     option = callback.wrapped_command.parser.options[0]
-    assert option.key == "meow"
-    assert option.names == ["--boop-oop"]
+    assert option.key == "other_value"
+    assert option.names == ["--other-value"]
     assert option.converters == []
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
+    assert option.min_length == 32
+    assert option.max_length == 4343
     assert option.min_value is None
     assert option.max_value is None
 
 
-def test_with_overridden_slash_name():
+@pytest.mark.parametrize(
+    ("type_", "value", "raw_type", "option_type"),
+    [
+        (annotations.Int, 543, int, hikari.OptionType.INTEGER),
+        (annotations.Float, 234.432, float, hikari.OptionType.FLOAT),
+    ],
+)
+def test_with_max(
+    type_: type[typing.Union[int, float]],
+    value: typing.Union[int, float],
+    raw_type: type[typing.Any],
+    option_type: hikari.OptionType,
+):
+    global type__
+    global value_
+    type__ = type_
+    value_ = value
+
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("command", "description")
     @tanjun.as_message_command("command")
     async def callback(
         ctx: tanjun.abc.Context,
-        necc: typing.Annotated[annotations.Int, annotations.Name(slash="nom"), "EEEE"],
-        nya: typing.Annotated[annotations.Str, annotations.Name(slash="sex"), "AAAA"] = "meow",
+        bee: typing.Annotated[type__, annotations.Max(value_), "eee"],  # type: ignore
+        yeet_no: typing.Annotated[typing.Union[type__, None], annotations.Max(value_), "eep"] = None,  # type: ignore
     ):
         ...
 
@@ -2624,167 +1235,148 @@ async def callback(
     assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
     assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
-            name="nom",
+            type=option_type,
+            name="bee",
             channel_types=None,
-            description="EEEE",
+            description="eee",
             is_required=True,
             min_value=None,
-            max_value=None,
+            max_value=value,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="sex",
+            type=option_type,
+            name="yeet_no",
             channel_types=None,
-            description="AAAA",
+            description="eep",
             is_required=False,
             min_value=None,
-            max_value=None,
+            max_value=value,
         ),
     ]
 
     assert len(callback._tracked_options) == 2
-    tracked_option = callback._tracked_options["nom"]
+    tracked_option = callback._tracked_options["bee"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
+    assert tracked_option.is_always_float is (raw_type is float)
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "necc"
-    assert tracked_option.name == "nom"
-    assert tracked_option.type is hikari.OptionType.INTEGER
+    assert tracked_option.key == "bee"
+    assert tracked_option.name == "bee"
+    assert tracked_option.type is option_type
 
-    tracked_option = callback._tracked_options["sex"]
+    tracked_option = callback._tracked_options["yeet_no"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
+    assert tracked_option.is_always_float is (raw_type is float)
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "nya"
-    assert tracked_option.name == "sex"
-    assert tracked_option.type is hikari.OptionType.STRING
+    assert tracked_option.key == "yeet_no"
+    assert tracked_option.name == "yeet_no"
+    assert tracked_option.type is option_type
 
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
-    assert argument.key == "necc"
-    assert argument.converters == [int]
+    assert argument.key == "bee"
+    assert argument.converters == [raw_type]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
     assert argument.min_length is None
     assert argument.max_length is None
     assert argument.min_value is None
-    assert argument.max_value is None
+    assert argument.max_value == value
 
     assert len(callback.wrapped_command.parser.options) == 1
     option = callback.wrapped_command.parser.options[0]
-    assert option.key == "nya"
-    assert option.names == ["--nya"]
-    assert option.converters == []
+    assert option.key == "yeet_no"
+    assert option.names == ["--yeet-no"]
+    assert option.converters == [raw_type]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
     assert option.min_length is None
     assert option.max_length is None
     assert option.min_value is None
-    assert option.max_value is None
+    assert option.max_value == value
 
 
-def test_with_overridden_message_name():
-    @annotations.with_annotated_args(follow_wrapped=True)
+def test_with_max_when_float_for_int():
     @tanjun.as_slash_command("command", "description")
     @tanjun.as_message_command("command")
     async def callback(
-        ctx: tanjun.abc.Context,
-        meow_meow: typing.Annotated[annotations.Str, annotations.Name(message="--blam-blam"), "Description"] = "neko",
-    ):
+        ctx: tanjun.abc.Context, value: typing.Annotated[annotations.Int, annotations.Max(123.312), "description"]
+    ) -> None:
         ...
 
-    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
-    assert callback.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.STRING,
-            name="meow_meow",
-            channel_types=None,
-            description="Description",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        )
-    ]
-
-    assert len(callback._tracked_options) == 1
-    tracked_option = callback._tracked_options["meow_meow"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "meow_meow"
-    assert tracked_option.name == "meow_meow"
-    assert tracked_option.type is hikari.OptionType.STRING
-
-    assert len(callback.wrapped_command.parser.arguments) == 0
-    assert len(callback.wrapped_command.parser.options) == 1
-    option = callback.wrapped_command.parser.options[0]
-    assert option.key == "meow_meow"
-    assert option.names == ["--blam-blam"]
-    assert option.converters == []
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
+    with pytest.raises(TypeError, match="Max value of type float is not valid for a int argument"):
+        annotations.with_annotated_args(follow_wrapped=True)(callback)
 
 
-def test_with_ranged():
+def test_with_max_when_int_for_float():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("command", "description")
     @tanjun.as_message_command("command")
     async def callback(
         ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Int, annotations.Ranged(44, 55), "meow"],
-        other_value: typing.Annotated[annotations.Float, annotations.Ranged(5433, 6524.32), "bye bye"] = 5,
-    ):
+        value: typing.Annotated[annotations.Float, annotations.Max(432), "description"],
+        other_value: typing.Annotated[typing.Union[annotations.Float, bool], annotations.Max(5431), "meow"] = False,
+    ) -> None:
         ...
 
     assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
     assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
     assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.INTEGER,
+            type=hikari.OptionType.FLOAT,
             name="value",
             channel_types=None,
-            description="meow",
+            description="description",
             is_required=True,
-            min_value=44,
-            max_value=55,
+            min_value=None,
+            max_value=432,
         ),
         hikari.CommandOption(
             type=hikari.OptionType.FLOAT,
             name="other_value",
             channel_types=None,
-            description="bye bye",
+            description="meow",
             is_required=False,
-            min_value=5433,
-            max_value=6524.32,
+            min_value=None,
+            max_value=5431,
         ),
     ]
 
+    assert len(callback._tracked_options) == 2
+    tracked_option = callback._tracked_options["value"]
+    assert tracked_option.converters == []
+    assert tracked_option.default is tanjun.abc.NO_DEFAULT
+    assert tracked_option.is_always_float is True
+    assert tracked_option.is_only_member is False
+    assert tracked_option.key == "value"
+    assert tracked_option.name == "value"
+    assert tracked_option.type is hikari.OptionType.FLOAT
+
+    tracked_option = callback._tracked_options["other_value"]
+    assert tracked_option.converters == []
+    assert tracked_option.default is tanjun.abc.NO_PASS
+    assert tracked_option.is_always_float is True
+    assert tracked_option.is_only_member is False
+    assert tracked_option.key == "other_value"
+    assert tracked_option.name == "other_value"
+    assert tracked_option.type is hikari.OptionType.FLOAT
+
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
     assert argument.key == "value"
-    assert argument.converters == [int]
+    assert argument.converters == [float]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
     assert argument.min_length is None
     assert argument.max_length is None
-    assert argument.min_value == 44
-    assert argument.max_value == 55
+    assert argument.min_value is None
+    assert argument.max_value == 432
 
     assert len(callback.wrapped_command.parser.options) == 1
-
     option = callback.wrapped_command.parser.options[0]
     assert option.key == "other_value"
     assert option.names == ["--other-value"]
@@ -2794,41 +1386,37 @@ async def callback(
     assert option.is_multi is False
     assert option.min_length is None
     assert option.max_length is None
-    assert option.min_value == 5433
-    assert option.max_value == 6524.32
+    assert option.min_value is None
+    assert option.max_value == 5431
 
 
 @pytest.mark.parametrize(
-    ("min_value", "max_value", "converter", "option_type"),
+    ("type_", "raw_type", "option_type", "value"),
     [
-        (123.132, 321, float, hikari.OptionType.FLOAT),
-        (123, 321, int, hikari.OptionType.INTEGER),
-        (431, 1232.321, float, hikari.OptionType.FLOAT),
-        (452.432, 55234.2134, float, hikari.OptionType.FLOAT),
+        (annotations.Int, int, hikari.OptionType.INTEGER, 123),
+        (annotations.Float, float, hikari.OptionType.FLOAT, 321.123),
     ],
 )
-def test_with_generic_ranged(
-    min_value: typing.Union[float, int],
-    max_value: typing.Union[float, int],
-    converter: typing.Union[type[float], type[int]],
+def test_with_min(
+    type_: type[typing.Union[int, float]],
+    raw_type: type[typing.Union[int, float]],
     option_type: hikari.OptionType,
+    value: typing.Union[int, float],
 ):
-    global min_value_
-    global max_value_
-    min_value_ = min_value
-    max_value_ = max_value
-
-    with pytest.warns(DeprecationWarning):
+    global type__
+    global value_
+    type__ = type_
+    value_ = value
 
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("command", "description")
-        @tanjun.as_message_command("command")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            number: typing.Annotated[annotations.Ranged[min_value_, max_value_], "meow"],  # type: ignore
-            other_number: typing.Annotated[annotations.Ranged[min_value_, max_value_], "nom"] = 443,  # type: ignore
-        ):
-            ...
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        number: typing.Annotated[type__, annotations.Max(value_), "eee"],  # type: ignore
+        other_number: typing.Annotated[type__, annotations.Max(value_), "eep"] = 54234,  # type: ignore
+    ):
+        ...
 
     assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
     assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
@@ -2837,19 +1425,19 @@ async def callback(
             type=option_type,
             name="number",
             channel_types=None,
-            description="meow",
+            description="eee",
             is_required=True,
-            min_value=min_value,
-            max_value=max_value,
+            min_value=None,
+            max_value=value,
         ),
         hikari.CommandOption(
             type=option_type,
             name="other_number",
             channel_types=None,
-            description="nom",
+            description="eep",
             is_required=False,
-            min_value=min_value,
-            max_value=max_value,
+            min_value=None,
+            max_value=value,
         ),
     ]
 
@@ -2857,7 +1445,7 @@ async def callback(
     tracked_option = callback._tracked_options["number"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is (converter is float)
+    assert tracked_option.is_always_float is (raw_type is float)
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "number"
     assert tracked_option.name == "number"
@@ -2866,7 +1454,7 @@ async def callback(
     tracked_option = callback._tracked_options["other_number"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is (converter is float)
+    assert tracked_option.is_always_float is (raw_type is float)
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "other_number"
     assert tracked_option.name == "other_number"
@@ -2875,254 +1463,177 @@ async def callback(
     assert len(callback.wrapped_command.parser.arguments) == 1
     argument = callback.wrapped_command.parser.arguments[0]
     assert argument.key == "number"
-    assert argument.converters == [converter]
+    assert argument.converters == [raw_type]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
     assert argument.min_length is None
     assert argument.max_length is None
-    assert argument.min_value == min_value
-    assert argument.max_value == max_value
+    assert argument.min_value is None
+    assert argument.max_value == value
 
     assert len(callback.wrapped_command.parser.options) == 1
     option = callback.wrapped_command.parser.options[0]
-    assert option.key == "other_number"
-    assert option.names == ["--other-number"]
-    assert option.converters == [converter]
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value == min_value
-    assert option.max_value == max_value
-
-
-def test_with_snowflake_or():
-    global mock_callback
-    mock_callback = mock.Mock()
-
-    @annotations.with_annotated_args(follow_wrapped=True)
-    @tanjun.as_message_command("command")
-    @tanjun.as_slash_command("yeet", "description")
-    async def callback(
-        ctx: tanjun.abc.Context,
-        value: typing.Annotated[annotations.Role, annotations.SnowflakeOr(parse_id=mock_callback), "se"],
-        value_2: typing.Annotated[typing.Optional[annotations.User], annotations.SnowflakeOr(), "x"] = None,
-    ) -> None:
-        ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
-
-    assert callback.wrapped_command.build().options == [
-        hikari.CommandOption(
-            type=hikari.OptionType.ROLE,
-            name="value",
-            channel_types=None,
-            description="se",
-            is_required=True,
-            min_value=None,
-            max_value=None,
-        ),
-        hikari.CommandOption(
-            type=hikari.OptionType.USER,
-            name="value_2",
-            channel_types=None,
-            description="x",
-            is_required=False,
-            min_value=None,
-            max_value=None,
-        ),
-    ]
-
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.ROLE
-
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.USER
-
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [mock_callback]
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_snowflake]
+    assert option.key == "other_number"
+    assert option.names == ["--other-number"]
+    assert option.converters == [raw_type]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
     assert option.min_length is None
     assert option.max_length is None
     assert option.min_value is None
-    assert option.max_value is None
+    assert option.max_value == value
 
 
-def test_with_generic_snowflake_or_for_channel():
-    with pytest.warns(DeprecationWarning):
+def test_with_min_when_float_for_int():
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context, value: typing.Annotated[annotations.Int, annotations.Min(234.432), "description"]
+    ) -> None:
+        ...
 
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Channel], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.Channel]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
+    with pytest.raises(TypeError, match="Min value of type float is not valid for a int argument"):
+        annotations.with_annotated_args(follow_wrapped=True)(callback)
 
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
 
-    assert callback.wrapped_command.build().options == [
+def test_with_min_when_int_for_float():
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        value: typing.Annotated[annotations.Float, annotations.Min(12333), "description"],
+        other_value: typing.Annotated[typing.Union[annotations.Float, bool], annotations.Min(44444), "meow"] = False,
+    ) -> None:
+        ...
+
+    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
+    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
+    assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.CHANNEL,
+            type=hikari.OptionType.FLOAT,
             name="value",
             channel_types=None,
-            description="se",
+            description="description",
             is_required=True,
-            min_value=None,
+            min_value=12333,
             max_value=None,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.CHANNEL,
-            name="value_2",
+            type=hikari.OptionType.FLOAT,
+            name="other_value",
             channel_types=None,
-            description="x",
+            description="meow",
             is_required=False,
-            min_value=None,
+            min_value=44444,
             max_value=None,
         ),
     ]
 
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
+    assert len(callback._tracked_options) == 2
+    tracked_option = callback._tracked_options["value"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
+    assert tracked_option.is_always_float is True
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "value"
     assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.CHANNEL
+    assert tracked_option.type is hikari.OptionType.FLOAT
 
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
+    tracked_option = callback._tracked_options["other_value"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
+    assert tracked_option.is_always_float is True
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.CHANNEL
+    assert tracked_option.key == "other_value"
+    assert tracked_option.name == "other_value"
+    assert tracked_option.type is hikari.OptionType.FLOAT
 
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
+    assert len(callback.wrapped_command.parser.arguments) == 1
+    argument = callback.wrapped_command.parser.arguments[0]
     assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_channel_id]
+    assert argument.converters == [float]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
     assert argument.min_length is None
     assert argument.max_length is None
-    assert argument.min_value is None
+    assert argument.min_value == 12333
     assert argument.max_value is None
 
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_channel_id]
+    assert len(callback.wrapped_command.parser.options) == 1
+    option = callback.wrapped_command.parser.options[0]
+    assert option.key == "other_value"
+    assert option.names == ["--other-value"]
+    assert option.converters == [float]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
     assert option.min_length is None
     assert option.max_length is None
-    assert option.min_value is None
+    assert option.min_value == 44444
     assert option.max_value is None
 
 
-def test_with_generic_snowflake_or_for_member():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Member], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.Member]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
+def test_with_overridden_name():
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        nyaa: typing.Annotated[annotations.Int, annotations.Name("boop"), "Nope"],
+        meow: typing.Annotated[annotations.Str, annotations.Name("meep_meep"), "Description"] = "meowow",
+    ):
+        ...
 
-    assert callback.wrapped_command.build().options == [
+    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
+    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
+    assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.USER,
-            name="value",
+            type=hikari.OptionType.INTEGER,
+            name="boop",
             channel_types=None,
-            description="se",
+            description="Nope",
             is_required=True,
             min_value=None,
             max_value=None,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.USER,
-            name="value_2",
+            type=hikari.OptionType.STRING,
+            name="meep_meep",
             channel_types=None,
-            description="x",
+            description="Description",
             is_required=False,
             min_value=None,
             max_value=None,
         ),
     ]
 
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
+    assert len(callback._tracked_options) == 2
+    tracked_option = callback._tracked_options["boop"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
     assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is True
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.USER
+    assert tracked_option.is_only_member is False
+    assert tracked_option.key == "nyaa"
+    assert tracked_option.name == "boop"
+    assert tracked_option.type is hikari.OptionType.INTEGER
 
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
+    tracked_option = callback._tracked_options["meep_meep"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
     assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is True
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.USER
+    assert tracked_option.is_only_member is False
+    assert tracked_option.key == "meow"
+    assert tracked_option.name == "meep_meep"
+    assert tracked_option.type is hikari.OptionType.STRING
 
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_user_id]
+    assert len(callback.wrapped_command.parser.arguments) == 1
+    argument = callback.wrapped_command.parser.arguments[0]
+    assert argument.key == "nyaa"
+    assert argument.converters == [int]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
@@ -3131,11 +1642,11 @@ async def callback(
     assert argument.min_value is None
     assert argument.max_value is None
 
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_user_id]
+    assert len(callback.wrapped_command.parser.options) == 1
+    option = callback.wrapped_command.parser.options[0]
+    assert option.key == "meow"
+    assert option.names == ["--meep-meep"]
+    assert option.converters == []
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
@@ -3145,68 +1656,65 @@ async def callback(
     assert option.max_value is None
 
 
-def test_with_generic_snowflake_or_for_mentionable():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Mentionable], "se"],  # type: ignore
-            value_2: typing.Annotated[
-                typing.Optional[annotations.SnowflakeOr[annotations.Mentionable]], "x"  # type: ignore
-            ] = None,
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
+def test_with_individually_overridden_name():
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        nyaa: typing.Annotated[annotations.Int, annotations.Name("nom", slash="oop"), "Nope"],
+        meow: typing.Annotated[
+            annotations.Str, annotations.Name("nom2", slash="n", message="--boop-oop"), "Description"
+        ] = "meowow",
+    ):
+        ...
 
-    assert callback.wrapped_command.build().options == [
+    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
+    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
+    assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.MENTIONABLE,
-            name="value",
+            type=hikari.OptionType.INTEGER,
+            name="oop",
             channel_types=None,
-            description="se",
+            description="Nope",
             is_required=True,
             min_value=None,
             max_value=None,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.MENTIONABLE,
-            name="value_2",
+            type=hikari.OptionType.STRING,
+            name="n",
             channel_types=None,
-            description="x",
+            description="Description",
             is_required=False,
             min_value=None,
             max_value=None,
         ),
     ]
 
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
+    assert len(callback._tracked_options) == 2
+    tracked_option = callback._tracked_options["oop"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.MENTIONABLE
+    assert tracked_option.key == "nyaa"
+    assert tracked_option.name == "oop"
+    assert tracked_option.type is hikari.OptionType.INTEGER
 
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
+    tracked_option = callback._tracked_options["n"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.MENTIONABLE
+    assert tracked_option.key == "meow"
+    assert tracked_option.name == "n"
+    assert tracked_option.type is hikari.OptionType.STRING
 
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_snowflake]
+    assert len(callback.wrapped_command.parser.arguments) == 1
+    argument = callback.wrapped_command.parser.arguments[0]
+    assert argument.key == "nyaa"
+    assert argument.converters == [int]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
@@ -3215,11 +1723,11 @@ async def callback(
     assert argument.min_value is None
     assert argument.max_value is None
 
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_snowflake]
+    assert len(callback.wrapped_command.parser.options) == 1
+    option = callback.wrapped_command.parser.options[0]
+    assert option.key == "meow"
+    assert option.names == ["--boop-oop"]
+    assert option.converters == []
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
@@ -3229,66 +1737,63 @@ async def callback(
     assert option.max_value is None
 
 
-def test_with_generic_snowflake_or_for_role():
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Role], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.Role]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
-
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
+def test_with_overridden_slash_name():
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        necc: typing.Annotated[annotations.Int, annotations.Name(slash="nom"), "EEEE"],
+        nya: typing.Annotated[annotations.Str, annotations.Name(slash="sex"), "AAAA"] = "meow",
+    ):
+        ...
 
-    assert callback.wrapped_command.build().options == [
+    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
+    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
+    assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.ROLE,
-            name="value",
+            type=hikari.OptionType.INTEGER,
+            name="nom",
             channel_types=None,
-            description="se",
+            description="EEEE",
             is_required=True,
             min_value=None,
             max_value=None,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.ROLE,
-            name="value_2",
+            type=hikari.OptionType.STRING,
+            name="sex",
             channel_types=None,
-            description="x",
+            description="AAAA",
             is_required=False,
             min_value=None,
             max_value=None,
         ),
     ]
 
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
+    assert len(callback._tracked_options) == 2
+    tracked_option = callback._tracked_options["nom"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_DEFAULT
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.ROLE
+    assert tracked_option.key == "necc"
+    assert tracked_option.name == "nom"
+    assert tracked_option.type is hikari.OptionType.INTEGER
 
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
+    tracked_option = callback._tracked_options["sex"]
     assert tracked_option.converters == []
     assert tracked_option.default is tanjun.abc.NO_PASS
     assert tracked_option.is_always_float is False
     assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.ROLE
+    assert tracked_option.key == "nya"
+    assert tracked_option.name == "sex"
+    assert tracked_option.type is hikari.OptionType.STRING
 
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
-    assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_role_id]
+    assert len(callback.wrapped_command.parser.arguments) == 1
+    argument = callback.wrapped_command.parser.arguments[0]
+    assert argument.key == "necc"
+    assert argument.converters == [int]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
@@ -3297,11 +1802,11 @@ async def callback(
     assert argument.min_value is None
     assert argument.max_value is None
 
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_role_id]
+    assert len(callback.wrapped_command.parser.options) == 1
+    option = callback.wrapped_command.parser.options[0]
+    assert option.key == "nya"
+    assert option.names == ["--nya"]
+    assert option.converters == []
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
@@ -3311,107 +1816,136 @@ async def callback(
     assert option.max_value is None
 
 
-def test_with_generic_snowflake_or_for_user():
-    with pytest.warns(DeprecationWarning):
+def test_with_overridden_message_name():
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        meow_meow: typing.Annotated[annotations.Str, annotations.Name(message="--blam-blam"), "Description"] = "neko",
+    ):
+        ...
 
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.User], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.User]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
+    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
+    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
+    assert callback.build().options == [
+        hikari.CommandOption(
+            type=hikari.OptionType.STRING,
+            name="meow_meow",
+            channel_types=None,
+            description="Description",
+            is_required=False,
+            min_value=None,
+            max_value=None,
+        )
+    ]
 
-    assert isinstance(callback.parser, tanjun.ShlexParser)
-    assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
+    assert len(callback._tracked_options) == 1
+    tracked_option = callback._tracked_options["meow_meow"]
+    assert tracked_option.converters == []
+    assert tracked_option.default is tanjun.abc.NO_PASS
+    assert tracked_option.is_always_float is False
+    assert tracked_option.is_only_member is False
+    assert tracked_option.key == "meow_meow"
+    assert tracked_option.name == "meow_meow"
+    assert tracked_option.type is hikari.OptionType.STRING
 
-    assert callback.wrapped_command.build().options == [
+    assert len(callback.wrapped_command.parser.arguments) == 0
+    assert len(callback.wrapped_command.parser.options) == 1
+    option = callback.wrapped_command.parser.options[0]
+    assert option.key == "meow_meow"
+    assert option.names == ["--blam-blam"]
+    assert option.converters == []
+    assert option.default is tanjun.abc.NO_PASS
+    assert option.empty_value is tanjun.abc.NO_DEFAULT
+    assert option.is_multi is False
+    assert option.min_length is None
+    assert option.max_length is None
+    assert option.min_value is None
+    assert option.max_value is None
+
+
+def test_with_ranged():
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_slash_command("command", "description")
+    @tanjun.as_message_command("command")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        value: typing.Annotated[annotations.Int, annotations.Ranged(44, 55), "meow"],
+        other_value: typing.Annotated[annotations.Float, annotations.Ranged(5433, 6524.32), "bye bye"] = 5,
+    ):
+        ...
+
+    assert isinstance(callback.wrapped_command, tanjun.MessageCommand)
+    assert isinstance(callback.wrapped_command.parser, tanjun.ShlexParser)
+    assert callback.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.USER,
+            type=hikari.OptionType.INTEGER,
             name="value",
             channel_types=None,
-            description="se",
+            description="meow",
             is_required=True,
-            min_value=None,
-            max_value=None,
+            min_value=44,
+            max_value=55,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.USER,
-            name="value_2",
+            type=hikari.OptionType.FLOAT,
+            name="other_value",
             channel_types=None,
-            description="x",
+            description="bye bye",
             is_required=False,
-            min_value=None,
-            max_value=None,
+            min_value=5433,
+            max_value=6524.32,
         ),
     ]
 
-    assert len(callback.wrapped_command._tracked_options) == 2
-    tracked_option = callback.wrapped_command._tracked_options["value"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value"
-    assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.USER
-
-    tracked_option = callback.wrapped_command._tracked_options["value_2"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "value_2"
-    assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.USER
-
-    assert len(callback.parser.arguments) == 1
-    argument = callback.parser.arguments[0]
+    assert len(callback.wrapped_command.parser.arguments) == 1
+    argument = callback.wrapped_command.parser.arguments[0]
     assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.parse_user_id]
+    assert argument.converters == [int]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
     assert argument.min_length is None
     assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
+    assert argument.min_value == 44
+    assert argument.max_value == 55
 
-    assert len(callback.parser.options) == 1
-    option = callback.parser.options[0]
-    assert option.key == "value_2"
-    assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.parse_user_id]
+    assert len(callback.wrapped_command.parser.options) == 1
+
+    option = callback.wrapped_command.parser.options[0]
+    assert option.key == "other_value"
+    assert option.names == ["--other-value"]
+    assert option.converters == [float]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
     assert option.min_length is None
     assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
+    assert option.min_value == 5433
+    assert option.max_value == 6524.32
 
 
-def test_with_generic_snowflake_or():
-    with pytest.warns(DeprecationWarning):
+def test_with_snowflake_or():
+    global mock_callback
+    mock_callback = mock.Mock()
 
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_message_command("command")
-        @tanjun.as_slash_command("yeet", "description")
-        async def callback(
-            ctx: tanjun.abc.Context,
-            value: typing.Annotated[annotations.SnowflakeOr[annotations.Bool], "se"],  # type: ignore
-            value_2: typing.Annotated[annotations.SnowflakeOr[typing.Optional[annotations.Bool]], "x"] = None,  # type: ignore
-        ) -> None:
-            ...
+    @annotations.with_annotated_args(follow_wrapped=True)
+    @tanjun.as_message_command("command")
+    @tanjun.as_slash_command("yeet", "description")
+    async def callback(
+        ctx: tanjun.abc.Context,
+        value: typing.Annotated[annotations.Role, annotations.SnowflakeOr(parse_id=mock_callback), "se"],
+        value_2: typing.Annotated[typing.Optional[annotations.User], annotations.SnowflakeOr(), "x"] = None,
+    ) -> None:
+        ...
 
     assert isinstance(callback.parser, tanjun.ShlexParser)
     assert isinstance(callback.wrapped_command, tanjun.SlashCommand)
 
     assert callback.wrapped_command.build().options == [
         hikari.CommandOption(
-            type=hikari.OptionType.BOOLEAN,
+            type=hikari.OptionType.ROLE,
             name="value",
             channel_types=None,
             description="se",
@@ -3420,7 +1954,7 @@ async def callback(
             max_value=None,
         ),
         hikari.CommandOption(
-            type=hikari.OptionType.BOOLEAN,
+            type=hikari.OptionType.USER,
             name="value_2",
             channel_types=None,
             description="x",
@@ -3438,7 +1972,7 @@ async def callback(
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "value"
     assert tracked_option.name == "value"
-    assert tracked_option.type is hikari.OptionType.BOOLEAN
+    assert tracked_option.type is hikari.OptionType.ROLE
 
     tracked_option = callback.wrapped_command._tracked_options["value_2"]
     assert tracked_option.converters == []
@@ -3447,12 +1981,12 @@ async def callback(
     assert tracked_option.is_only_member is False
     assert tracked_option.key == "value_2"
     assert tracked_option.name == "value_2"
-    assert tracked_option.type is hikari.OptionType.BOOLEAN
+    assert tracked_option.type is hikari.OptionType.USER
 
     assert len(callback.parser.arguments) == 1
     argument = callback.parser.arguments[0]
     assert argument.key == "value"
-    assert argument.converters == [tanjun.conversion.to_bool]
+    assert argument.converters == [mock_callback]
     assert argument.default is tanjun.abc.NO_DEFAULT
     assert argument.is_greedy is False
     assert argument.is_multi is False
@@ -3465,7 +1999,7 @@ async def callback(
     option = callback.parser.options[0]
     assert option.key == "value_2"
     assert option.names == ["--value-2"]
-    assert option.converters == [tanjun.conversion.to_bool]
+    assert option.converters == [tanjun.conversion.parse_snowflake]
     assert option.default is tanjun.abc.NO_PASS
     assert option.empty_value is tanjun.abc.NO_DEFAULT
     assert option.is_multi is False
@@ -3598,113 +2132,6 @@ async def command(
     assert option.max_value is None
 
 
-def test_with_generic_these_channels():  # noqa: CFQ001
-    with pytest.warns(DeprecationWarning):
-
-        @annotations.with_annotated_args(follow_wrapped=True)
-        @tanjun.as_slash_command("name", "description")
-        @tanjun.as_message_command("name")
-        async def command(
-            ctx: tanjun.abc.Context,
-            bb: typing.Annotated[annotations.TheseChannels[hikari.GuildChannel], "nep"],  # type: ignore
-            bat: typing.Annotated[
-                typing.Optional[annotations.TheseChannels[hikari.GuildVoiceChannel, hikari.PrivateChannel]], "bip"  # type: ignore
-            ] = None,
-        ):
-            ...
-
-    expected_types_1 = {
-        hikari.ChannelType.GUILD_CATEGORY,
-        hikari.ChannelType.GUILD_NEWS,
-        hikari.ChannelType.GUILD_NEWS_THREAD,
-        hikari.ChannelType.GUILD_PRIVATE_THREAD,
-        hikari.ChannelType.GUILD_PUBLIC_THREAD,
-        hikari.ChannelType.GUILD_STAGE,
-        hikari.ChannelType.GUILD_TEXT,
-        hikari.ChannelType.GUILD_VOICE,
-        hikari.ChannelType.GUILD_FORUM,
-    }
-    expected_types_2 = {hikari.ChannelType.DM, hikari.ChannelType.GROUP_DM, hikari.ChannelType.GUILD_VOICE}
-
-    assert isinstance(command.wrapped_command, tanjun.MessageCommand)
-    assert isinstance(command.wrapped_command.parser, tanjun.ShlexParser)
-
-    assert len(command.build().options) == 2
-    option = command.build().options[0]
-    assert option.type is hikari.OptionType.CHANNEL
-    assert option.name == "bb"
-    assert option.description == "nep"
-    assert option.is_required is True
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-    assert option.channel_types
-    assert len(option.channel_types) == 9
-    assert set(option.channel_types) == expected_types_1
-
-    option = command.build().options[1]
-    assert option.type is hikari.OptionType.CHANNEL
-    assert option.name == "bat"
-    assert option.description == "bip"
-    assert option.is_required is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-    assert option.channel_types
-    assert len(option.channel_types) == 3
-    assert set(option.channel_types) == expected_types_2
-
-    assert len(command._tracked_options) == 2
-    tracked_option = command._tracked_options["bb"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_DEFAULT
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bb"
-    assert tracked_option.name == "bb"
-    assert tracked_option.type is hikari.OptionType.CHANNEL
-
-    tracked_option = command._tracked_options["bat"]
-    assert tracked_option.converters == []
-    assert tracked_option.default is tanjun.abc.NO_PASS
-    assert tracked_option.is_always_float is False
-    assert tracked_option.is_only_member is False
-    assert tracked_option.key == "bat"
-    assert tracked_option.name == "bat"
-    assert tracked_option.type is hikari.OptionType.CHANNEL
-
-    assert len(command.wrapped_command.parser.arguments) == 1
-    argument = command.wrapped_command.parser.arguments[0]
-    assert argument.key == "bb"
-    assert len(argument.converters) == 1
-    assert isinstance(argument.converters[0], tanjun.conversion.ToChannel)
-    assert argument.converters[0]._allowed_types == expected_types_1
-    assert argument.default is tanjun.abc.NO_DEFAULT
-    assert argument.is_greedy is False
-    assert argument.is_multi is False
-    assert argument.min_length is None
-    assert argument.max_length is None
-    assert argument.min_value is None
-    assert argument.max_value is None
-
-    assert len(command.wrapped_command.parser.options) == 1
-    option = command.wrapped_command.parser.options[0]
-    assert option.key == "bat"
-    assert option.names == ["--bat"]
-    assert len(option.converters) == 1
-    assert isinstance(option.converters[0], tanjun.conversion.ToChannel)
-    assert option.converters[0]._allowed_types == expected_types_2
-    assert option.default is tanjun.abc.NO_PASS
-    assert option.empty_value is tanjun.abc.NO_DEFAULT
-    assert option.is_multi is False
-    assert option.min_length is None
-    assert option.max_length is None
-    assert option.min_value is None
-    assert option.max_value is None
-
-
 def test_for_attachment_option():
     @annotations.with_annotated_args(follow_wrapped=True)
     @tanjun.as_slash_command("meow", "nom")
diff --git a/tests/test_conversion.py b/tests/test_conversion.py
index a6ced7237..d2faca68e 100644
--- a/tests/test_conversion.py
+++ b/tests/test_conversion.py
@@ -51,14 +51,6 @@ class TestBaseConverter:
     def test_check_client(self):
         ...
 
-    def test_async_caches_property(self):
-        with pytest.warns(DeprecationWarning, match="Use .caches instead"):
-            assert tanjun.conversion.BaseConverter().async_caches == []
-
-    def test_cache_components_property(self):
-        with pytest.warns(DeprecationWarning, match="Use .caches instead"):
-            assert tanjun.conversion.BaseConverter().cache_components is hikari.api.CacheComponents.NONE
-
     @pytest.mark.parametrize(
         ("obj", "expected"),
         [
@@ -176,10 +168,6 @@ def test_caches_property(
     ):
         assert obj.caches == expected
 
-    def test_intents_property(self):
-        with pytest.warns(DeprecationWarning, match="Use .caches instead"):
-            assert tanjun.conversion.BaseConverter().intents is hikari.Intents.NONE
-
     @pytest.mark.parametrize(
         ("obj", "expected"),
         [
diff --git a/tests/test_injecting.py b/tests/test_injecting.py
deleted file mode 100644
index 9a7da826e..000000000
--- a/tests/test_injecting.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# -*- coding: utf-8 -*-
-# BSD 3-Clause License
-#
-# Copyright (c) 2020-2023, Faster Speeding
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-#
-# * Neither the name of the copyright holder nor the names of its
-#   contributors may be used to endorse or promote products derived from
-#   this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# pyright: reportPrivateUsage=none
-
-import alluka
-import mock
-
-import tanjun
-
-
-def test_as_self_injecting():
-    mock_callback = mock.Mock()
-    mock_client = mock.Mock()
-
-    result = tanjun.injecting.as_self_injecting(mock_client)(mock_callback)
-
-    assert result.callback is mock_callback
-    assert result._client is mock_client.injector
-
-
-def test_aliases():
-    assert set(tanjun.injecting.__all__) == {
-        "AbstractInjectionContext",
-        "BasicInjectionContext",
-        "CallbackSig",
-        "Injected",
-        "InjectorClient",
-        "SelfInjectingCallback",
-        "UNDEFINED",
-        "Undefined",
-        "UndefinedOr",
-        "as_self_injecting",
-        "inject",
-        "injected",
-    }
-    assert tanjun.injecting.SelfInjectingCallback is alluka.AsyncSelfInjecting
-    assert tanjun.injecting.BasicInjectionContext is alluka.BasicContext
-    assert tanjun.injecting.InjectorClient is alluka.Client
-    assert tanjun.injecting.Injected is alluka.Injected
-    assert tanjun.injecting.inject is alluka.inject
-    assert tanjun.injecting.injected is alluka.inject
-    assert tanjun.injecting.UNDEFINED is alluka.abc.UNDEFINED
-    assert tanjun.injecting.CallbackSig is alluka.abc.CallbackSig
-    assert tanjun.injecting.AbstractInjectionContext is alluka.abc.Context
-    assert tanjun.injecting.Undefined is alluka.abc.Undefined
diff --git a/tests/test_utilities.py b/tests/test_utilities.py
deleted file mode 100644
index 059069c02..000000000
--- a/tests/test_utilities.py
+++ /dev/null
@@ -1,52 +0,0 @@
-# -*- coding: utf-8 -*-
-# BSD 3-Clause License
-#
-# Copyright (c) 2020-2023, Faster Speeding
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice, this
-#   list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright notice,
-#   this list of conditions and the following disclaimer in the documentation
-#   and/or other materials provided with the distribution.
-#
-# * Neither the name of the copyright holder nor the names of its
-#   contributors may be used to endorse or promote products derived from
-#   this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-# SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-# pyright: reportPrivateUsage=none
-# This leads to too many false-positives around mocks.
-
-import tanjun
-
-
-def test_aliases():
-    assert set(tanjun.utilities.__all__) == {
-        "ALL_PERMISSIONS",
-        "DM_PERMISSIONS",
-        "calculate_everyone_permissions",
-        "calculate_permissions",
-        "fetch_everyone_permissions",
-        "fetch_permissions",
-    }
-    assert tanjun.utilities.ALL_PERMISSIONS is tanjun.permissions.ALL_PERMISSIONS
-    assert tanjun.utilities.DM_PERMISSIONS is tanjun.permissions.DM_PERMISSIONS
-    assert tanjun.utilities.calculate_everyone_permissions is tanjun.permissions.calculate_everyone_permissions
-    assert tanjun.utilities.calculate_permissions is tanjun.permissions.calculate_permissions
-    assert tanjun.utilities.fetch_everyone_permissions is tanjun.permissions.fetch_everyone_permissions
-    assert tanjun.utilities.fetch_permissions is tanjun.permissions.fetch_permissions