{"repo": "DisnakeDev/disnake", "n_pairs": 144, "version": "v2_function_scoped", "contexts": {"tests/test_http.py::47": {"resolved_imports": ["disnake/http.py"], "used_names": ["HTTPClient", "pytest"], "enclosing_function": "test_format_gateway_url", "extracted_code": "# Source: disnake/http.py\nclass HTTPClient:\n    \"\"\"Represents an HTTP client sending HTTP requests to the Discord API.\"\"\"\n\n    def __init__(\n        self,\n        connector: aiohttp.BaseConnector | None = None,\n        *,\n        loop: asyncio.AbstractEventLoop,\n        proxy: str | None = None,\n        proxy_auth: aiohttp.BasicAuth | None = None,\n        unsync_clock: bool = True,\n    ) -> None:\n        self.loop: asyncio.AbstractEventLoop = loop\n        self.connector = connector\n        self.__session: aiohttp.ClientSession = MISSING  # filled in static_login\n        self._locks: weakref.WeakValueDictionary[str, asyncio.Lock] = weakref.WeakValueDictionary()\n        self._global_over: asyncio.Event = asyncio.Event()\n        self._global_over.set()\n        self.token: str | None = None\n        self.bot_token: bool = False\n        self.proxy: str | None = proxy\n        self.proxy_auth: aiohttp.BasicAuth | None = proxy_auth\n        self.use_clock: bool = not unsync_clock\n\n        user_agent = \"DiscordBot (https://github.com/DisnakeDev/disnake {0}) Python/{1[0]}.{1[1]} aiohttp/{2}\"\n        self.user_agent: str = user_agent.format(__version__, sys.version_info, aiohttp.__version__)\n\n    def recreate(self) -> None:\n        if self.__session.closed:\n            self.__session = aiohttp.ClientSession(\n                connector=self.connector, ws_response_class=DiscordClientWebSocketResponse\n            )\n\n    async def ws_connect(self, url: str, *, compress: int = 0) -> aiohttp.ClientWebSocketResponse:\n        timeout = cast(\n            \"Any\",\n            aiohttp.ClientWSTimeout(ws_close=30.0)  # pyright: ignore[reportCallIssue]\n            if hasattr(aiohttp, \"ClientWSTimeout\")\n            else 30.0,\n        )\n        return await self.__session.ws_connect(\n            url,\n            proxy_auth=self.proxy_auth,\n            proxy=self.proxy,\n            max_msg_size=0,\n            timeout=timeout,\n            autoclose=False,\n            headers={\n                \"User-Agent\": self.user_agent,\n            },\n            compress=compress,\n        )\n\n    async def request(\n        self,\n        route: Route,\n        *,\n        files: Sequence[File] | None = None,\n        form: Iterable[dict[str, Any]] | None = None,\n        **kwargs: Any,\n    ) -> Any:\n        bucket = route.bucket\n        method = route.method\n        url = route.url\n\n        lock = self._locks.get(bucket)\n        if lock is None:\n            self._locks[bucket] = lock = asyncio.Lock()\n\n        # header creation\n        headers: dict[str, str] = {\n            \"User-Agent\": self.user_agent,\n        }\n\n        if self.token is not None:\n            headers[\"Authorization\"] = \"Bot \" + self.token\n        # some checking if it's a JSON request\n        if \"json\" in kwargs:\n            headers[\"Content-Type\"] = \"application/json\"\n            kwargs[\"data\"] = utils._to_json(kwargs.pop(\"json\"))\n\n        try:\n            reason = kwargs.pop(\"reason\")\n        except KeyError:\n            pass\n        else:\n            if reason:\n                headers[\"X-Audit-Log-Reason\"] = _uriquote(reason, safe=\"/ \")\n\n        kwargs[\"headers\"] = headers\n\n        # Proxy support\n        if self.proxy is not None:\n            kwargs[\"proxy\"] = self.proxy\n        if self.proxy_auth is not None:\n            kwargs[\"proxy_auth\"] = self.proxy_auth\n\n        if not self._global_over.is_set():\n            # wait until the global lock is complete\n            await self._global_over.wait()\n\n        response: aiohttp.ClientResponse | None = None\n        data: dict[str, Any] | str | None = None\n        await lock.acquire()\n        with MaybeUnlock(lock) as maybe_lock:\n            for tries in range(5):\n                if files:\n                    for f in files:\n                        f.reset(seek=tries)\n\n                if form:\n                    # NOTE: for `quote_fields`, see https://github.com/aio-libs/aiohttp/issues/4012\n                    form_data = aiohttp.FormData(quote_fields=False)\n                    for p in form:\n                        # manually escape chars, just in case\n                        name = re.sub(\n                            r\"[^\\x21\\x23-\\x5b\\x5d-\\x7e]\", lambda m: f\"\\\\{m.group(0)}\", p[\"name\"]\n                        )\n                        form_data.add_field(\n                            name=name, **{k: v for k, v in p.items() if k != \"name\"}\n                        )\n                    kwargs[\"data\"] = form_data\n\n                try:\n                    async with self.__session.request(method, url, **kwargs) as response:\n                        _log.debug(\n                            \"%s %s with %s has returned %s\",\n                            method,\n                            url,\n                            kwargs.get(\"data\"),\n                            response.status,\n                        )\n\n                        # even errors have text involved in them so this is safe to call\n                        data = await json_or_text(response)\n\n                        # check if we have rate limit header information\n                        remaining = response.headers.get(\"X-Ratelimit-Remaining\")\n                        if remaining == \"0\" and response.status != 429:\n                            # we've depleted our current bucket\n                            delta = utils._parse_ratelimit_header(\n                                response, use_clock=self.use_clock\n                            )\n                            _log.debug(\n                                \"A rate limit bucket has been exhausted (bucket: %s, retry: %s).\",\n                                bucket,\n                                delta,\n                            )\n                            maybe_lock.defer()\n                            self.loop.call_later(delta, lock.release)\n\n                        # the request was successful so just return the text/json\n                        if 300 > response.status >= 200:\n                            _log.debug(\"%s %s has received %s\", method, url, data)\n                            return data\n\n                        # we are being rate limited\n                        if response.status == 429:\n                            if not response.headers.get(\"Via\") or isinstance(data, str):\n                                # Banned by Cloudflare more than likely.\n                                raise HTTPException(response, data)\n\n                            fmt = 'We are being rate limited. Retrying in %.2f seconds. Handled under the bucket \"%s\"'\n\n                            # sleep a bit\n                            retry_after: float = data[\"retry_after\"]\n                            _log.warning(fmt, retry_after, bucket)\n\n                            # check if it's a global rate limit\n                            is_global = data.get(\"global\", False)\n                            if is_global:\n                                _log.warning(\n                                    \"Global rate limit has been hit. Retrying in %.2f seconds.\",\n                                    retry_after,\n                                )\n                                self._global_over.clear()\n\n                            await asyncio.sleep(retry_after)\n                            _log.debug(\"Done sleeping for the rate limit. Retrying...\")\n\n                            # release the global lock now that the\n                            # global rate limit has passed\n                            if is_global:\n                                self._global_over.set()\n                                _log.debug(\"Global rate limit is now over.\")\n\n                            continue\n\n                        # we've received a 500, 502, or 504, unconditional retry\n                        if response.status in {500, 502, 504}:\n                            await asyncio.sleep(1 + tries * 2)\n                            continue\n\n                        # the usual error cases\n                        if response.status == 403:\n                            raise Forbidden(response, data)\n                        elif response.status == 404:\n                            raise NotFound(response, data)\n                        elif response.status >= 500:\n                            raise DiscordServerError(response, data)\n                        else:\n                            raise HTTPException(response, data)\n\n                # This is handling exceptions from the request\n                except OSError as e:\n                    # Connection reset by peer\n                    if tries < 4 and e.errno == ECONNRESET:\n                        await asyncio.sleep(1 + tries * 2)\n                        continue\n                    raise\n\n            if response is not None:\n                # We've run out of retries, raise.\n                if response.status >= 500:\n                    raise DiscordServerError(response, data)\n\n                raise HTTPException(response, data)\n\n            msg = \"Unreachable code in HTTP handling\"\n            raise RuntimeError(msg)\n\n    async def get_from_cdn(self, url: str) -> bytes:\n        async with self.__session.get(url) as resp:\n            if resp.status == 200:\n                return await resp.read()\n            elif resp.status == 404:\n                raise NotFound(resp, \"asset not found\")\n            elif resp.status == 403:\n                raise Forbidden(resp, \"cannot retrieve asset\")\n            else:\n                raise HTTPException(resp, \"failed to get asset\")\n\n    # state management\n\n    async def close(self) -> None:\n        if self.__session:\n            await self.__session.close()\n\n    # login management\n\n    async def static_login(self, token: str) -> user.User:\n        # Necessary to get aiohttp to stop complaining about session creation\n        self.__session = aiohttp.ClientSession(\n            connector=self.connector, ws_response_class=DiscordClientWebSocketResponse\n        )\n        old_token = self.token\n        self.token = token\n\n        try:\n            data: user.User = await self.request(Route(\"GET\", \"/users/@me\"))\n        except HTTPException as exc:\n            self.token = old_token\n            if exc.status == 401:\n                msg = \"Improper token has been passed.\"\n                raise LoginFailure(msg) from exc\n            raise\n\n        return data\n\n    def create_party(\n        self,\n        channel_id: Snowflake,\n        max_age: int,\n        max_uses: int,\n        target_application_id: Snowflake,\n        *,\n        reason: str | None = None,\n    ) -> Response[invite.Invite]:\n        payload = {\n            \"max_age\": max_age,\n            \"max_uses\": max_uses,\n            \"target_application_id\": target_application_id,\n            \"target_type\": 2,\n            \"temporary\": False,\n            \"validate\": None,\n        }\n        return self.request(\n            Route(\"POST\", \"/channels/{channel_id}/invites\", channel_id=channel_id),\n            json=payload,\n            reason=reason,\n        )\n\n    # Group functionality\n\n    def start_group(\n        self, user_id: Snowflake, recipients: list[int]\n    ) -> Response[channel.GroupDMChannel]:\n        payload = {\n            \"recipients\": recipients,\n        }\n\n        return self.request(\n            Route(\"POST\", \"/users/{user_id}/channels\", user_id=user_id), json=payload\n        )\n\n    def leave_group(self, channel_id: Snowflake) -> Response[None]:\n        return self.request(Route(\"DELETE\", \"/channels/{channel_id}\", channel_id=channel_id))\n\n    # Message management\n\n    def start_private_message(self, user_id: Snowflake) -> Response[channel.DMChannel]:\n        payload = {\n            \"recipient_id\": user_id,\n        }\n\n        return self.request(Route(\"POST\", \"/users/@me/channels\"), json=payload)\n\n    def send_message(\n        self,\n        channel_id: Snowflake,\n        content: str | None,\n        *,\n        tts: bool = False,\n        embed: embed.Embed | None = None,\n        embeds: list[embed.Embed] | None = None,\n        nonce: str | int | None = None,\n        allowed_mentions: message.AllowedMentions | None = None,\n        message_reference: message.MessageReference | None = None,\n        stickers: Sequence[Snowflake] | None = None,\n        components: Sequence[components.Component] | None = None,\n        poll: poll.PollCreatePayload | None = None,\n        flags: int | None = None,\n    ) -> Response[message.Message]:\n        r = Route(\"POST\", \"/channels/{channel_id}/messages\", channel_id=channel_id)\n        payload: dict[str, Any] = {}\n\n        if content:\n            payload[\"content\"] = content\n\n        if tts:\n            payload[\"tts\"] = True\n\n        if embed:\n            payload[\"embeds\"] = [embed]\n\n        if embeds:\n            payload[\"embeds\"] = embeds\n\n        if nonce:\n            payload[\"nonce\"] = nonce\n\n        if allowed_mentions:\n            payload[\"allowed_mentions\"] = allowed_mentions\n\n        if message_reference:\n            payload[\"message_reference\"] = message_reference\n\n        if components:\n            payload[\"components\"] = components\n\n        if stickers:\n            payload[\"sticker_ids\"] = stickers\n\n        if flags is not None:\n            payload[\"flags\"] = flags\n\n        if poll is not None:\n            payload[\"poll\"] = poll\n\n        return self.request(r, json=payload)\n\n    def get_poll_answer_voters(\n        self,\n        channel_id: Snowflake,\n        message_id: Snowflake,\n        answer_id: int,\n        *,\n        after: Snowflake | None = None,\n        limit: int | None = None,\n    ) -> Response[poll.PollVoters]:\n        params: dict[str, Any] = {}\n\n        if after is not None:\n            params[\"after\"] = after\n        if limit is not None:\n            params[\"limit\"] = limit\n\n        return self.request(\n            Route(\n                \"GET\",\n                \"/channels/{channel_id}/polls/{message_id}/answers/{answer_id}\",\n                channel_id=channel_id,\n                message_id=message_id,\n                answer_id=answer_id,\n            ),\n            params=params,\n        )\n\n    def expire_poll(\n        self, channel_id: Snowflake, message_id: Snowflake\n    ) -> Response[message.Message]:\n        return self.request(\n            Route(\n                \"POST\",\n                \"/channels/{channel_id}/polls/{message_id}/expire\",\n                channel_id=channel_id,\n                message_id=message_id,\n            )\n        )\n\n    def send_typing(self, channel_id: Snowflake) -> Response[None]:\n        return self.request(Route(\"POST\", \"/channels/{channel_id}/typing\", channel_id=channel_id))\n\n    def send_multipart_helper(\n        self,\n        route: Route,\n        *,\n        files: Sequence[File],\n        content: str | None = None,\n        tts: bool = False,\n        embed: embed.Embed | None = None,\n        embeds: list[embed.Embed] | None = None,\n        nonce: str | int | None = None,\n        allowed_mentions: message.AllowedMentions | None = None,\n        message_reference: message.MessageReference | None = None,\n        stickers: Sequence[Snowflake] | None = None,\n        components: Sequence[components.Component] | None = None,\n        poll: poll.PollCreatePayload | None = None,\n        flags: int | None = None,\n    ) -> Response[message.Message]:\n        payload: dict[str, Any] = {\"tts\": tts}\n        if content:\n            payload[\"content\"] = content\n        if embed:\n            payload[\"embeds\"] = [embed]\n        if embeds:\n            payload[\"embeds\"] = embeds\n        if nonce:\n            payload[\"nonce\"] = nonce\n        if allowed_mentions:\n            payload[\"allowed_mentions\"] = allowed_mentions\n        if message_reference:\n            payload[\"message_reference\"] = message_reference\n        if components:\n            payload[\"components\"] = components\n        if stickers:\n            payload[\"sticker_ids\"] = stickers\n        if flags is not None:\n            payload[\"flags\"] = flags\n        if poll:\n            payload[\"poll\"] = poll\n\n        multipart = to_multipart_with_attachments(payload, files)\n\n        return self.request(route, form=multipart, files=files)\n\n    def send_files(\n        self,\n        channel_id: Snowflake,\n        *,\n        files: Sequence[File],\n        content: str | None = None,\n        tts: bool = False,\n        embed: embed.Embed | None = None,\n        embeds: list[embed.Embed] | None = None,\n        nonce: str | int | None = None,\n        allowed_mentions: message.AllowedMentions | None = None,\n        message_reference: message.MessageReference | None = None,\n        stickers: Sequence[Snowflake] | None = None,\n        components: Sequence[components.Component] | None = None,\n        poll: poll.PollCreatePayload | None = None,\n        flags: int | None = None,\n    ) -> Response[message.Message]:\n        r = Route(\"POST\", \"/channels/{channel_id}/messages\", channel_id=channel_id)\n        return self.send_multipart_helper(\n            r,\n            files=files,\n            content=content,\n            tts=tts,\n            embed=embed,\n            embeds=embeds,\n            nonce=nonce,\n            allowed_mentions=allowed_mentions,\n            message_reference=message_reference,\n            stickers=stickers,\n            components=components,\n            poll=poll,\n            flags=flags,\n        )\n\n    def delete_message(\n        self, channel_id: Snowflake, message_id: Snowflake, *, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/channels/{channel_id}/messages/{message_id}\",\n            channel_id=channel_id,\n            message_id=message_id,\n        )\n        return self.request(r, reason=reason)\n\n    def delete_messages(\n        self, channel_id: Snowflake, message_ids: SnowflakeList, *, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\"POST\", \"/channels/{channel_id}/messages/bulk-delete\", channel_id=channel_id)\n        payload = {\n            \"messages\": message_ids,\n        }\n\n        return self.request(r, json=payload, reason=reason)\n\n    def edit_message(\n        self,\n        channel_id: Snowflake,\n        message_id: Snowflake,\n        *,\n        files: list[File] | None = None,\n        **fields: Any,\n    ) -> Response[message.Message]:\n        r = Route(\n            \"PATCH\",\n            \"/channels/{channel_id}/messages/{message_id}\",\n            channel_id=channel_id,\n            message_id=message_id,\n        )\n        if files:\n            multipart = to_multipart_with_attachments(fields, files)\n            return self.request(r, form=multipart, files=files)\n        return self.request(r, json=fields)\n\n    def add_reaction(\n        self, channel_id: Snowflake, message_id: Snowflake, emoji: str\n    ) -> Response[None]:\n        r = Route(\n            \"PUT\",\n            \"/channels/{channel_id}/messages/{message_id}/reactions/{emoji}/@me\",\n            channel_id=channel_id,\n            message_id=message_id,\n            emoji=emoji,\n        )\n        return self.request(r)\n\n    def remove_reaction(\n        self, channel_id: Snowflake, message_id: Snowflake, emoji: str, member_id: Snowflake\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/channels/{channel_id}/messages/{message_id}/reactions/{emoji}/{member_id}\",\n            channel_id=channel_id,\n            message_id=message_id,\n            member_id=member_id,\n            emoji=emoji,\n        )\n        return self.request(r)\n\n    def remove_own_reaction(\n        self, channel_id: Snowflake, message_id: Snowflake, emoji: str\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/channels/{channel_id}/messages/{message_id}/reactions/{emoji}/@me\",\n            channel_id=channel_id,\n            message_id=message_id,\n            emoji=emoji,\n        )\n        return self.request(r)\n\n    def get_reaction_users(\n        self,\n        channel_id: Snowflake,\n        message_id: Snowflake,\n        emoji: str,\n        limit: int,\n        after: Snowflake | None = None,\n    ) -> Response[list[user.User]]:\n        r = Route(\n            \"GET\",\n            \"/channels/{channel_id}/messages/{message_id}/reactions/{emoji}\",\n            channel_id=channel_id,\n            message_id=message_id,\n            emoji=emoji,\n        )\n\n        params: dict[str, Any] = {\n            \"limit\": limit,\n        }\n        if after:\n            params[\"after\"] = after\n        return self.request(r, params=params)\n\n    def clear_reactions(self, channel_id: Snowflake, message_id: Snowflake) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/channels/{channel_id}/messages/{message_id}/reactions\",\n            channel_id=channel_id,\n            message_id=message_id,\n        )\n\n        return self.request(r)\n\n    def clear_single_reaction(\n        self, channel_id: Snowflake, message_id: Snowflake, emoji: str\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/channels/{channel_id}/messages/{message_id}/reactions/{emoji}\",\n            channel_id=channel_id,\n            message_id=message_id,\n            emoji=emoji,\n        )\n        return self.request(r)\n\n    def get_message(\n        self, channel_id: Snowflake, message_id: Snowflake\n    ) -> Response[message.Message]:\n        r = Route(\n            \"GET\",\n            \"/channels/{channel_id}/messages/{message_id}\",\n            channel_id=channel_id,\n            message_id=message_id,\n        )\n        return self.request(r)\n\n    def get_channel(self, channel_id: Snowflake) -> Response[channel.Channel]:\n        r = Route(\"GET\", \"/channels/{channel_id}\", channel_id=channel_id)\n        return self.request(r)\n\n    def logs_from(\n        self,\n        channel_id: Snowflake,\n        limit: int,\n        before: Snowflake | None = None,\n        after: Snowflake | None = None,\n        around: Snowflake | None = None,\n    ) -> Response[list[message.Message]]:\n        params: dict[str, Any] = {\n            \"limit\": limit,\n        }\n\n        if before is not None:\n            params[\"before\"] = before\n        if after is not None:\n            params[\"after\"] = after\n        if around is not None:\n            params[\"around\"] = around\n\n        return self.request(\n            Route(\"GET\", \"/channels/{channel_id}/messages\", channel_id=channel_id), params=params\n        )\n\n    def publish_message(\n        self, channel_id: Snowflake, message_id: Snowflake\n    ) -> Response[message.Message]:\n        return self.request(\n            Route(\n                \"POST\",\n                \"/channels/{channel_id}/messages/{message_id}/crosspost\",\n                channel_id=channel_id,\n                message_id=message_id,\n            )\n        )\n\n    def pin_message(\n        self, channel_id: Snowflake, message_id: Snowflake, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\n            \"PUT\",\n            \"/channels/{channel_id}/messages/pins/{message_id}\",\n            channel_id=channel_id,\n            message_id=message_id,\n        )\n        return self.request(r, reason=reason)\n\n    def unpin_message(\n        self, channel_id: Snowflake, message_id: Snowflake, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/channels/{channel_id}/messages/pins/{message_id}\",\n            channel_id=channel_id,\n            message_id=message_id,\n        )\n        return self.request(r, reason=reason)\n\n    def get_pins(\n        self,\n        channel_id: Snowflake,\n        limit: int,\n        before: Snowflake | None = None,\n    ) -> Response[channel.ChannelPins]:\n        r = Route(\n            \"GET\",\n            \"/channels/{channel_id}/messages/pins\",\n            channel_id=channel_id,\n        )\n        params: dict[str, Any] = {\"limit\": limit}\n\n        if before is not None:\n            params[\"before\"] = before\n\n        return self.request(r, params=params)\n\n    # Member management\n\n    def search_guild_members(\n        self, guild_id: Snowflake, query: str, limit: int = 1\n    ) -> Response[list[member.MemberWithUser]]:\n        r = Route(\"GET\", \"/guilds/{guild_id}/members/search\", guild_id=guild_id)\n\n        return self.request(r, params={\"query\": query, \"limit\": limit})\n\n    def kick(\n        self, user_id: Snowflake, guild_id: Snowflake, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\", \"/guilds/{guild_id}/members/{user_id}\", guild_id=guild_id, user_id=user_id\n        )\n\n        return self.request(r, reason=reason)\n\n    def ban(\n        self,\n        user_id: Snowflake,\n        guild_id: Snowflake,\n        *,\n        delete_message_seconds: int = 86400,\n        reason: str | None = None,\n    ) -> Response[None]:\n        r = Route(\"PUT\", \"/guilds/{guild_id}/bans/{user_id}\", guild_id=guild_id, user_id=user_id)\n        payload = {\n            \"delete_message_seconds\": delete_message_seconds,\n        }\n\n        return self.request(r, json=payload, reason=reason)\n\n    def unban(\n        self, user_id: Snowflake, guild_id: Snowflake, *, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\"DELETE\", \"/guilds/{guild_id}/bans/{user_id}\", guild_id=guild_id, user_id=user_id)\n        return self.request(r, reason=reason)\n\n    def bulk_ban(\n        self,\n        user_ids: list[Snowflake],\n        guild_id: Snowflake,\n        *,\n        delete_message_seconds: int = 0,\n        reason: str | None = None,\n    ) -> Response[guild.BulkBanResult]:\n        r = Route(\"POST\", \"/guilds/{guild_id}/bulk-ban\", guild_id=guild_id)\n        payload = {\n            \"user_ids\": user_ids,\n            \"delete_message_seconds\": delete_message_seconds,\n        }\n\n        return self.request(r, json=payload, reason=reason)\n\n    def get_guild_voice_regions(self, guild_id: Snowflake) -> Response[list[voice.VoiceRegion]]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/regions\", guild_id=guild_id))\n\n    def guild_voice_state(\n        self,\n        user_id: Snowflake,\n        guild_id: Snowflake,\n        *,\n        mute: bool | None = None,\n        deafen: bool | None = None,\n        reason: str | None = None,\n    ) -> Response[member.Member]:\n        r = Route(\n            \"PATCH\", \"/guilds/{guild_id}/members/{user_id}\", guild_id=guild_id, user_id=user_id\n        )\n        payload = {}\n        if mute is not None:\n            payload[\"mute\"] = mute\n\n        if deafen is not None:\n            payload[\"deaf\"] = deafen\n\n        return self.request(r, json=payload, reason=reason)\n\n    def edit_profile(self, payload: dict[str, Any]) -> Response[user.User]:\n        return self.request(Route(\"PATCH\", \"/users/@me\"), json=payload)\n\n    def change_nickname(\n        self,\n        guild_id: Snowflake,\n        user_id: Snowflake,\n        nickname: str,\n        *,\n        reason: str | None = None,\n    ) -> Response[member.Member]:\n        r = Route(\n            \"PATCH\", \"/guilds/{guild_id}/members/{user_id}\", guild_id=guild_id, user_id=user_id\n        )\n        payload = {\n            \"nick\": nickname,\n        }\n        return self.request(r, json=payload, reason=reason)\n\n    def get_my_voice_state(self, guild_id: Snowflake) -> Response[voice.GuildVoiceState]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/voice-states/@me\", guild_id=guild_id))\n\n    def get_voice_state(\n        self, guild_id: Snowflake, user_id: Snowflake\n    ) -> Response[voice.GuildVoiceState]:\n        r = Route(\n            \"GET\", \"/guilds/{guild_id}/voice-states/{user_id}\", guild_id=guild_id, user_id=user_id\n        )\n        return self.request(r)\n\n    def edit_my_voice_state(self, guild_id: Snowflake, payload: dict[str, Any]) -> Response[None]:\n        r = Route(\"PATCH\", \"/guilds/{guild_id}/voice-states/@me\", guild_id=guild_id)\n        return self.request(r, json=payload)\n\n    def edit_voice_state(\n        self, guild_id: Snowflake, user_id: Snowflake, payload: dict[str, Any]\n    ) -> Response[None]:\n        r = Route(\n            \"PATCH\", \"/guilds/{guild_id}/voice-states/{user_id}\", guild_id=guild_id, user_id=user_id\n        )\n        return self.request(r, json=payload)\n\n    def edit_my_member(\n        self,\n        guild_id: Snowflake,\n        *,\n        reason: str | None = None,\n        **fields: Any,\n    ) -> Response[member.MemberWithUser]:\n        r = Route(\"PATCH\", \"/guilds/{guild_id}/members/@me\", guild_id=guild_id)\n        return self.request(r, json=fields, reason=reason)\n\n    def edit_member(\n        self,\n        guild_id: Snowflake,\n        user_id: Snowflake,\n        *,\n        reason: str | None = None,\n        **fields: Any,\n    ) -> Response[member.MemberWithUser]:\n        r = Route(\n            \"PATCH\", \"/guilds/{guild_id}/members/{user_id}\", guild_id=guild_id, user_id=user_id\n        )\n        return self.request(r, json=fields, reason=reason)\n\n    # Channel management\n\n    def edit_channel(\n        self,\n        channel_id: Snowflake,\n        *,\n        reason: str | None = None,\n        **options: Any,\n    ) -> Response[channel.Channel]:\n        r = Route(\"PATCH\", \"/channels/{channel_id}\", channel_id=channel_id)\n        valid_keys = (\n            \"name\",\n            \"parent_id\",\n            \"topic\",\n            \"bitrate\",\n            \"nsfw\",\n            \"user_limit\",\n            \"position\",\n            \"permission_overwrites\",\n            \"rate_limit_per_user\",\n            \"default_thread_rate_limit_per_user\",\n            \"type\",\n            \"rtc_region\",\n            \"video_quality_mode\",\n            \"archived\",\n            \"auto_archive_duration\",\n            \"locked\",\n            \"invitable\",\n            \"default_auto_archive_duration\",\n            \"flags\",\n            \"available_tags\",\n            \"applied_tags\",\n            \"default_reaction_emoji\",\n            \"default_sort_order\",\n            \"default_forum_layout\",\n        )\n        payload = {k: v for k, v in options.items() if k in valid_keys}\n        return self.request(r, reason=reason, json=payload)\n\n    def bulk_channel_update(\n        self,\n        guild_id: Snowflake,\n        data: list[guild.ChannelPositionUpdate],\n        *,\n        reason: str | None = None,\n    ) -> Response[None]:\n        r = Route(\"PATCH\", \"/guilds/{guild_id}/channels\", guild_id=guild_id)\n        return self.request(r, json=data, reason=reason)\n\n    def create_channel(\n        self,\n        guild_id: Snowflake,\n        channel_type: channel.ChannelType,\n        *,\n        reason: str | None = None,\n        **options: Any,\n    ) -> Response[channel.GuildChannel]:\n        payload = {\n            \"type\": channel_type,\n        }\n\n        valid_keys = (\n            \"name\",\n            \"parent_id\",\n            \"topic\",\n            \"bitrate\",\n            \"nsfw\",\n            \"user_limit\",\n            \"position\",\n            \"permission_overwrites\",\n            \"rate_limit_per_user\",\n            \"default_thread_rate_limit_per_user\",\n            \"rtc_region\",\n            \"video_quality_mode\",\n            \"auto_archive_duration\",\n            \"default_auto_archive_duration\",\n            \"flags\",\n            \"available_tags\",\n            \"default_reaction_emoji\",\n            \"default_sort_order\",\n            \"default_forum_layout\",\n        )\n        payload.update({k: v for k, v in options.items() if k in valid_keys and v is not None})\n\n        return self.request(\n            Route(\"POST\", \"/guilds/{guild_id}/channels\", guild_id=guild_id),\n            json=payload,\n            reason=reason,\n        )\n\n    def delete_channel(\n        self,\n        channel_id: Snowflake,\n        *,\n        reason: str | None = None,\n    ) -> Response[None]:\n        return self.request(\n            Route(\"DELETE\", \"/channels/{channel_id}\", channel_id=channel_id), reason=reason\n        )\n\n    # Thread management\n\n    def start_thread_with_message(\n        self,\n        channel_id: Snowflake,\n        message_id: Snowflake,\n        *,\n        name: str,\n        auto_archive_duration: threads.ThreadArchiveDurationLiteral,\n        rate_limit_per_user: int | None = None,\n        reason: str | None = None,\n    ) -> Response[threads.Thread]:\n        payload = {\n            \"name\": name,\n            \"auto_archive_duration\": auto_archive_duration,\n        }\n\n        if rate_limit_per_user is not None:\n            payload[\"rate_limit_per_user\"] = rate_limit_per_user\n\n        route = Route(\n            \"POST\",\n            \"/channels/{channel_id}/messages/{message_id}/threads\",\n            channel_id=channel_id,\n            message_id=message_id,\n        )\n        return self.request(route, json=payload, reason=reason)\n\n    def start_thread_without_message(\n        self,\n        channel_id: Snowflake,\n        *,\n        name: str,\n        auto_archive_duration: threads.ThreadArchiveDurationLiteral,\n        type: threads.ThreadType,\n        invitable: bool = True,\n        rate_limit_per_user: int | None = None,\n        reason: str | None = None,\n    ) -> Response[threads.Thread]:\n        payload = {\n            \"name\": name,\n            \"auto_archive_duration\": auto_archive_duration,\n            \"type\": type,\n            \"invitable\": invitable,\n        }\n\n        if rate_limit_per_user is not None:\n            payload[\"rate_limit_per_user\"] = rate_limit_per_user\n\n        route = Route(\"POST\", \"/channels/{channel_id}/threads\", channel_id=channel_id)\n        return self.request(route, json=payload, reason=reason)\n\n    def join_thread(self, channel_id: Snowflake) -> Response[None]:\n        return self.request(\n            Route(\"PUT\", \"/channels/{channel_id}/thread-members/@me\", channel_id=channel_id)\n        )\n\n    def add_user_to_thread(self, channel_id: Snowflake, user_id: Snowflake) -> Response[None]:\n        return self.request(\n            Route(\n                \"PUT\",\n                \"/channels/{channel_id}/thread-members/{user_id}\",\n                channel_id=channel_id,\n                user_id=user_id,\n            )\n        )\n\n    def leave_thread(self, channel_id: Snowflake) -> Response[None]:\n        return self.request(\n            Route(\"DELETE\", \"/channels/{channel_id}/thread-members/@me\", channel_id=channel_id)\n        )\n\n    def remove_user_from_thread(self, channel_id: Snowflake, user_id: Snowflake) -> Response[None]:\n        route = Route(\n            \"DELETE\",\n            \"/channels/{channel_id}/thread-members/{user_id}\",\n            channel_id=channel_id,\n            user_id=user_id,\n        )\n        return self.request(route)\n\n    def get_public_archived_threads(\n        self, channel_id: Snowflake, before: Snowflake | None = None, limit: int = 50\n    ) -> Response[threads.ThreadPaginationPayload]:\n        route = Route(\n            \"GET\", \"/channels/{channel_id}/threads/archived/public\", channel_id=channel_id\n        )\n\n        params = {}\n        if before:\n            params[\"before\"] = before\n        params[\"limit\"] = limit\n        return self.request(route, params=params)\n\n    def get_private_archived_threads(\n        self, channel_id: Snowflake, before: Snowflake | None = None, limit: int = 50\n    ) -> Response[threads.ThreadPaginationPayload]:\n        route = Route(\n            \"GET\", \"/channels/{channel_id}/threads/archived/private\", channel_id=channel_id\n        )\n\n        params: dict[str, Any] = {}\n        if before:\n            params[\"before\"] = before\n        params[\"limit\"] = limit\n        return self.request(route, params=params)\n\n    def get_joined_private_archived_threads(\n        self, channel_id: Snowflake, before: Snowflake | None = None, limit: int = 50\n    ) -> Response[threads.ThreadPaginationPayload]:\n        route = Route(\n            \"GET\",\n            \"/channels/{channel_id}/users/@me/threads/archived/private\",\n            channel_id=channel_id,\n        )\n        params: dict[str, Any] = {}\n        if before:\n            params[\"before\"] = before\n        params[\"limit\"] = limit\n        return self.request(route, params=params)\n\n    def get_active_threads(self, guild_id: Snowflake) -> Response[threads.ThreadPaginationPayload]:\n        route = Route(\"GET\", \"/guilds/{guild_id}/threads/active\", guild_id=guild_id)\n        return self.request(route)\n\n    def get_thread_member(\n        self, channel_id: Snowflake, user_id: Snowflake\n    ) -> Response[threads.ThreadMember]:\n        route = Route(\n            \"GET\",\n            \"/channels/{channel_id}/thread-members/{user_id}\",\n            channel_id=channel_id,\n            user_id=user_id,\n        )\n        return self.request(route)\n\n    def get_thread_members(self, channel_id: Snowflake) -> Response[list[threads.ThreadMember]]:\n        route = Route(\"GET\", \"/channels/{channel_id}/thread-members\", channel_id=channel_id)\n        return self.request(route)\n\n    def start_thread_in_forum_channel(\n        self,\n        channel_id: Snowflake,\n        files: Sequence[File] | None = None,\n        reason: str | None = None,\n        **fields: Any,\n    ) -> Response[threads.ForumThread]:\n        valid_thread_keys = (\n            \"name\",\n            \"auto_archive_duration\",\n            \"rate_limit_per_user\",\n            \"applied_tags\",\n            \"type\",\n        )\n        valid_message_keys = (\n            \"content\",\n            \"embeds\",\n            \"allowed_mentions\",\n            \"components\",\n            \"sticker_ids\",\n            \"flags\",\n        )\n        payload = {k: v for k, v in fields.items() if k in valid_thread_keys}\n        payload[\"message\"] = {k: v for k, v in fields.items() if k in valid_message_keys}\n\n        route = Route(\"POST\", \"/channels/{channel_id}/threads\", channel_id=channel_id)\n        query_params = {\"use_nested_fields\": 1}\n\n        if files:\n            # This cannot directly call `to_multipart_with_attachments`,\n            # since attachment data needs to be added to the nested `message` object\n            set_attachments(payload[\"message\"], files)\n            multipart = to_multipart(payload, files)\n\n            return self.request(\n                route, form=multipart, params=query_params, files=files, reason=reason\n            )\n\n        return self.request(route, json=payload, params=query_params, reason=reason)\n\n    # Webhook management\n\n    def create_webhook(\n        self,\n        channel_id: Snowflake,\n        *,\n        name: str,\n        avatar: str | None = None,\n        reason: str | None = None,\n    ) -> Response[webhook.Webhook]:\n        payload: dict[str, Any] = {\n            \"name\": name,\n        }\n        if avatar is not None:\n            payload[\"avatar\"] = avatar\n\n        r = Route(\"POST\", \"/channels/{channel_id}/webhooks\", channel_id=channel_id)\n        return self.request(r, json=payload, reason=reason)\n\n    def channel_webhooks(self, channel_id: Snowflake) -> Response[list[webhook.Webhook]]:\n        return self.request(Route(\"GET\", \"/channels/{channel_id}/webhooks\", channel_id=channel_id))\n\n    def guild_webhooks(self, guild_id: Snowflake) -> Response[list[webhook.Webhook]]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/webhooks\", guild_id=guild_id))\n\n    def get_webhook(self, webhook_id: Snowflake) -> Response[webhook.Webhook]:\n        return self.request(Route(\"GET\", \"/webhooks/{webhook_id}\", webhook_id=webhook_id))\n\n    def follow_webhook(\n        self,\n        channel_id: Snowflake,\n        webhook_channel_id: Snowflake,\n        reason: str | None = None,\n    ) -> Response[None]:\n        payload = {\n            \"webhook_channel_id\": str(webhook_channel_id),\n        }\n        return self.request(\n            Route(\"POST\", \"/channels/{channel_id}/followers\", channel_id=channel_id),\n            json=payload,\n            reason=reason,\n        )\n\n    # Guild management\n\n    def get_guilds(\n        self,\n        limit: int,\n        before: Snowflake | None = None,\n        after: Snowflake | None = None,\n        with_counts: bool = True,\n    ) -> Response[list[guild.Guild]]:\n        params: dict[str, Any] = {\n            \"limit\": limit,\n            \"with_counts\": int(with_counts),\n        }\n\n        if before:\n            params[\"before\"] = before\n        if after:\n            params[\"after\"] = after\n\n        return self.request(Route(\"GET\", \"/users/@me/guilds\"), params=params)\n\n    def leave_guild(self, guild_id: Snowflake) -> Response[None]:\n        return self.request(Route(\"DELETE\", \"/users/@me/guilds/{guild_id}\", guild_id=guild_id))\n\n    def get_guild(self, guild_id: Snowflake, *, with_counts: bool = True) -> Response[guild.Guild]:\n        params = {\"with_counts\": int(with_counts)}\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}\", guild_id=guild_id), params=params)\n\n    def delete_guild(self, guild_id: Snowflake) -> Response[None]:\n        return self.request(Route(\"DELETE\", \"/guilds/{guild_id}\", guild_id=guild_id))\n\n    def create_guild(\n        self,\n        name: str,\n        icon: str | None = None,\n        *,\n        verification_level: guild.VerificationLevel | None = None,\n        default_message_notifications: guild.DefaultMessageNotificationLevel | None = None,\n        explicit_content_filter: guild.ExplicitContentFilterLevel | None = None,\n        roles: list[guild.CreateGuildPlaceholderRole] | None = None,\n        channels: list[guild.CreateGuildPlaceholderChannel] | None = None,\n        afk_channel: Snowflake | None = None,\n        afk_timeout: int | None = None,\n        system_channel: Snowflake | None = None,\n        system_channel_flags: int | None = None,\n    ) -> Response[guild.Guild]:\n        payload: guild.CreateGuild = {\n            \"name\": name,\n        }\n        if icon:\n            payload[\"icon\"] = icon\n        if verification_level is not None:\n            payload[\"verification_level\"] = verification_level\n        if default_message_notifications is not None:\n            payload[\"default_message_notifications\"] = default_message_notifications\n        if explicit_content_filter is not None:\n            payload[\"explicit_content_filter\"] = explicit_content_filter\n        if roles is not None:\n            payload[\"roles\"] = roles\n        if channels is not None:\n            payload[\"channels\"] = channels\n        if afk_channel is not None:\n            payload[\"afk_channel_id\"] = afk_channel\n        if afk_timeout is not None:\n            payload[\"afk_timeout\"] = afk_timeout\n        if system_channel is not None:\n            payload[\"system_channel_id\"] = system_channel\n        if system_channel_flags is not None:\n            payload[\"system_channel_flags\"] = system_channel_flags\n\n        return self.request(Route(\"POST\", \"/guilds\"), json=payload)\n\n    def edit_guild(\n        self, guild_id: Snowflake, *, reason: str | None = None, **fields: Any\n    ) -> Response[guild.Guild]:\n        valid_keys = (\n            \"name\",\n            \"icon\",\n            \"afk_timeout\",\n            \"owner_id\",\n            \"afk_channel_id\",\n            \"splash\",\n            \"discovery_splash\",\n            \"features\",\n            \"verification_level\",\n            \"system_channel_id\",\n            \"default_message_notifications\",\n            \"description\",\n            \"explicit_content_filter\",\n            \"banner\",\n            \"system_channel_flags\",\n            \"rules_channel_id\",\n            \"public_updates_channel_id\",\n            \"preferred_locale\",\n            \"premium_progress_bar_enabled\",\n            \"safety_alerts_channel_id\",\n        )\n\n        payload = {k: v for k, v in fields.items() if k in valid_keys}\n\n        return self.request(\n            Route(\"PATCH\", \"/guilds/{guild_id}\", guild_id=guild_id), json=payload, reason=reason\n        )\n\n    def edit_guild_incident_actions(\n        self, guild_id: Snowflake, payload: guild.IncidentsData\n    ) -> Response[guild.IncidentsData]:\n        r = Route(\"PUT\", \"/guilds/{guild_id}/incident-actions\", guild_id=guild_id)\n        return self.request(r, json=payload)\n\n    def get_template(self, code: str) -> Response[template.Template]:\n        return self.request(Route(\"GET\", \"/guilds/templates/{code}\", code=code))\n\n    def guild_templates(self, guild_id: Snowflake) -> Response[list[template.Template]]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/templates\", guild_id=guild_id))\n\n    def create_template(\n        self, guild_id: Snowflake, payload: template.CreateTemplate\n    ) -> Response[template.Template]:\n        return self.request(\n            Route(\"POST\", \"/guilds/{guild_id}/templates\", guild_id=guild_id), json=payload\n        )\n\n    def sync_template(self, guild_id: Snowflake, code: str) -> Response[template.Template]:\n        return self.request(\n            Route(\"PUT\", \"/guilds/{guild_id}/templates/{code}\", guild_id=guild_id, code=code)\n        )\n\n    def edit_template(\n        self, guild_id: Snowflake, code: str, payload: dict[str, Any]\n    ) -> Response[template.Template]:\n        valid_keys = (\n            \"name\",\n            \"description\",\n        )\n        payload = {k: v for k, v in payload.items() if k in valid_keys}\n        return self.request(\n            Route(\"PATCH\", \"/guilds/{guild_id}/templates/{code}\", guild_id=guild_id, code=code),\n            json=payload,\n        )\n\n    def delete_template(self, guild_id: Snowflake, code: str) -> Response[None]:\n        return self.request(\n            Route(\"DELETE\", \"/guilds/{guild_id}/templates/{code}\", guild_id=guild_id, code=code)\n        )\n\n    def create_from_template(self, code: str, name: str, icon: str | None) -> Response[guild.Guild]:\n        payload = {\n            \"name\": name,\n        }\n        if icon:\n            payload[\"icon\"] = icon\n        return self.request(Route(\"POST\", \"/guilds/templates/{code}\", code=code), json=payload)\n\n    def get_guild_preview(self, guild_id: Snowflake) -> Response[guild.GuildPreview]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/preview\", guild_id=guild_id))\n\n    def get_bans(\n        self,\n        guild_id: Snowflake,\n        limit: int | None = None,\n        before: Snowflake | None = None,\n        after: Snowflake | None = None,\n    ) -> Response[list[guild.Ban]]:\n        params: dict[str, Any] = {}\n\n        if limit is not None:\n            params[\"limit\"] = limit\n        if before is not None:\n            params[\"before\"] = before\n        if after is not None:\n            params[\"after\"] = after\n\n        return self.request(\n            Route(\"GET\", \"/guilds/{guild_id}/bans\", guild_id=guild_id), params=params\n        )\n\n    def get_ban(self, user_id: Snowflake, guild_id: Snowflake) -> Response[guild.Ban]:\n        return self.request(\n            Route(\"GET\", \"/guilds/{guild_id}/bans/{user_id}\", guild_id=guild_id, user_id=user_id)\n        )\n\n    def get_vanity_code(self, guild_id: Snowflake) -> Response[invite.VanityInvite]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/vanity-url\", guild_id=guild_id))\n\n    def change_vanity_code(\n        self, guild_id: Snowflake, code: str, *, reason: str | None = None\n    ) -> Response[None]:\n        payload: dict[str, Any] = {\"code\": code}\n        return self.request(\n            Route(\"PATCH\", \"/guilds/{guild_id}/vanity-url\", guild_id=guild_id),\n            json=payload,\n            reason=reason,\n        )\n\n    def edit_mfa_level(\n        self, guild_id: Snowflake, mfa_level: guild.MFALevel, *, reason: str | None = None\n    ) -> Response[guild.MFALevelUpdate]:\n        payload: guild.MFALevelUpdate = {\"level\": mfa_level}\n        return self.request(\n            Route(\"POST\", \"/guilds/{guild_id}/mfa\", guild_id=guild_id),\n            json=payload,\n            reason=reason,\n        )\n\n    def get_all_guild_channels(self, guild_id: Snowflake) -> Response[list[guild.GuildChannel]]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/channels\", guild_id=guild_id))\n\n    def get_members(\n        self, guild_id: Snowflake, limit: int, after: Snowflake | None\n    ) -> Response[list[member.MemberWithUser]]:\n        params: dict[str, Any] = {\n            \"limit\": limit,\n        }\n        if after:\n            params[\"after\"] = after\n\n        r = Route(\"GET\", \"/guilds/{guild_id}/members\", guild_id=guild_id)\n        return self.request(r, params=params)\n\n    def get_member(\n        self, guild_id: Snowflake, member_id: Snowflake\n    ) -> Response[member.MemberWithUser]:\n        return self.request(\n            Route(\n                \"GET\",\n                \"/guilds/{guild_id}/members/{member_id}\",\n                guild_id=guild_id,\n                member_id=member_id,\n            )\n        )\n\n    def prune_members(\n        self,\n        guild_id: Snowflake,\n        days: int,\n        compute_prune_count: bool,\n        roles: list[str],\n        *,\n        reason: str | None = None,\n    ) -> Response[guild.GuildPrune]:\n        payload: dict[str, Any] = {\n            \"days\": days,\n            \"compute_prune_count\": \"true\" if compute_prune_count else \"false\",\n        }\n        if roles:\n            payload[\"include_roles\"] = \", \".join(roles)\n\n        return self.request(\n            Route(\"POST\", \"/guilds/{guild_id}/prune\", guild_id=guild_id),\n            json=payload,\n            reason=reason,\n        )\n\n    def estimate_pruned_members(\n        self,\n        guild_id: Snowflake,\n        days: int,\n        roles: list[str],\n    ) -> Response[guild.GuildPrune]:\n        params: dict[str, Any] = {\n            \"days\": days,\n        }\n        if roles:\n            params[\"include_roles\"] = \", \".join(roles)\n\n        return self.request(\n            Route(\"GET\", \"/guilds/{guild_id}/prune\", guild_id=guild_id), params=params\n        )\n\n    def get_sticker(self, sticker_id: Snowflake) -> Response[sticker.Sticker]:\n        return self.request(Route(\"GET\", \"/stickers/{sticker_id}\", sticker_id=sticker_id))\n\n    def get_sticker_pack(self, pack_id: Snowflake) -> Response[sticker.StickerPack]:\n        return self.request(Route(\"GET\", \"/sticker-packs/{pack_id}\", pack_id=pack_id))\n\n    def list_sticker_packs(self) -> Response[sticker.ListStickerPacks]:\n        return self.request(Route(\"GET\", \"/sticker-packs\"))\n\n    def get_all_guild_stickers(self, guild_id: Snowflake) -> Response[list[sticker.GuildSticker]]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/stickers\", guild_id=guild_id))\n\n    def get_guild_sticker(\n        self, guild_id: Snowflake, sticker_id: Snowflake\n    ) -> Response[sticker.GuildSticker]:\n        return self.request(\n            Route(\n                \"GET\",\n                \"/guilds/{guild_id}/stickers/{sticker_id}\",\n                guild_id=guild_id,\n                sticker_id=sticker_id,\n            )\n        )\n\n    def create_guild_sticker(\n        self,\n        guild_id: Snowflake,\n        payload: sticker.CreateGuildSticker,\n        file: File,\n        *,\n        reason: str | None = None,\n    ) -> Response[sticker.GuildSticker]:\n        initial_bytes = file.fp.read(16)\n\n        try:\n            mime_type = utils._get_mime_type_for_data(initial_bytes)\n        except ValueError:\n            if initial_bytes.startswith(b\"{\"):\n                mime_type = \"application/json\"\n            else:\n                mime_type = \"application/octet-stream\"\n        finally:\n            file.reset()\n\n        form: list[dict[str, Any]] = [\n            {\n                \"name\": \"file\",\n                \"value\": file.fp,\n                \"filename\": file.filename,\n                \"content_type\": mime_type,\n            }\n        ]\n\n        for k, v in payload.items():\n            form.append(\n                {\n                    \"name\": k,\n                    \"value\": v,\n                }\n            )\n\n        return self.request(\n            Route(\"POST\", \"/guilds/{guild_id}/stickers\", guild_id=guild_id),\n            form=form,\n            files=[file],\n            reason=reason,\n        )\n\n    def modify_guild_sticker(\n        self,\n        guild_id: Snowflake,\n        sticker_id: Snowflake,\n        payload: sticker.EditGuildSticker,\n        *,\n        reason: str | None = None,\n    ) -> Response[sticker.GuildSticker]:\n        return self.request(\n            Route(\n                \"PATCH\",\n                \"/guilds/{guild_id}/stickers/{sticker_id}\",\n                guild_id=guild_id,\n                sticker_id=sticker_id,\n            ),\n            json=payload,\n            reason=reason,\n        )\n\n    def delete_guild_sticker(\n        self, guild_id: Snowflake, sticker_id: Snowflake, *, reason: str | None = None\n    ) -> Response[None]:\n        return self.request(\n            Route(\n                \"DELETE\",\n                \"/guilds/{guild_id}/stickers/{sticker_id}\",\n                guild_id=guild_id,\n                sticker_id=sticker_id,\n            ),\n            reason=reason,\n        )\n\n    def get_all_app_emojis(self, app_id: Snowflake) -> Response[emoji.ListAppEmoji]:\n        return self.request(Route(\"GET\", \"/applications/{app_id}/emojis\", app_id=app_id))\n\n    def get_app_emoji(self, app_id: Snowflake, emoji_id: Snowflake) -> Response[emoji.Emoji]:\n        return self.request(\n            Route(\n                \"GET\", \"/applications/{app_id}/emojis/{emoji_id}\", app_id=app_id, emoji_id=emoji_id\n            )\n        )\n\n    def get_all_custom_emojis(self, guild_id: Snowflake) -> Response[list[emoji.Emoji]]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/emojis\", guild_id=guild_id))\n\n    def get_custom_emoji(self, guild_id: Snowflake, emoji_id: Snowflake) -> Response[emoji.Emoji]:\n        return self.request(\n            Route(\n                \"GET\", \"/guilds/{guild_id}/emojis/{emoji_id}\", guild_id=guild_id, emoji_id=emoji_id\n            )\n        )\n\n    def create_app_emoji(\n        self, app_id: Snowflake, *, name: str, image: str\n    ) -> Response[emoji.Emoji]:\n        payload: dict[str, Any] = {\n            \"name\": name,\n            \"image\": image,\n        }\n\n        r = Route(\"POST\", \"/applications/{app_id}/emojis\", app_id=app_id)\n        return self.request(r, json=payload)\n\n    def edit_app_emoji(\n        self, app_id: Snowflake, emoji_id: Snowflake, *, name: str\n    ) -> Response[emoji.Emoji]:\n        payload: dict[str, Any] = {\n            \"name\": name,\n        }\n\n        r = Route(\n            \"PATCH\", \"/applications/{app_id}/emojis/{emoji_id}\", app_id=app_id, emoji_id=emoji_id\n        )\n        return self.request(r, json=payload)\n\n    def delete_app_emoji(self, app_id: Snowflake, emoji_id: Snowflake) -> Response[None]:\n        return self.request(\n            Route(\n                \"DELETE\",\n                \"/applications/{app_id}/emojis/{emoji_id}\",\n                app_id=app_id,\n                emoji_id=emoji_id,\n            )\n        )\n\n    def create_custom_emoji(\n        self,\n        guild_id: Snowflake,\n        name: str,\n        image: str,\n        *,\n        roles: SnowflakeList | None = None,\n        reason: str | None = None,\n    ) -> Response[emoji.Emoji]:\n        payload: dict[str, Any] = {\n            \"name\": name,\n            \"image\": image,\n            \"roles\": roles or [],\n        }\n\n        r = Route(\"POST\", \"/guilds/{guild_id}/emojis\", guild_id=guild_id)\n        return self.request(r, json=payload, reason=reason)\n\n    def delete_custom_emoji(\n        self,\n        guild_id: Snowflake,\n        emoji_id: Snowflake,\n        *,\n        reason: str | None = None,\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\", \"/guilds/{guild_id}/emojis/{emoji_id}\", guild_id=guild_id, emoji_id=emoji_id\n        )\n        return self.request(r, reason=reason)\n\n    def edit_custom_emoji(\n        self,\n        guild_id: Snowflake,\n        emoji_id: Snowflake,\n        *,\n        payload: dict[str, Any],\n        reason: str | None = None,\n    ) -> Response[emoji.Emoji]:\n        r = Route(\n            \"PATCH\", \"/guilds/{guild_id}/emojis/{emoji_id}\", guild_id=guild_id, emoji_id=emoji_id\n        )\n        return self.request(r, json=payload, reason=reason)\n\n    def get_all_integrations(self, guild_id: Snowflake) -> Response[list[integration.Integration]]:\n        r = Route(\"GET\", \"/guilds/{guild_id}/integrations\", guild_id=guild_id)\n\n        return self.request(r)\n\n    def create_integration(\n        self, guild_id: Snowflake, type: integration.IntegrationType, id: int\n    ) -> Response[None]:\n        payload = {\n            \"type\": type,\n            \"id\": id,\n        }\n\n        r = Route(\"POST\", \"/guilds/{guild_id}/integrations\", guild_id=guild_id)\n        return self.request(r, json=payload)\n\n    def edit_integration(\n        self, guild_id: Snowflake, integration_id: Snowflake, **payload: Any\n    ) -> Response[None]:\n        r = Route(\n            \"PATCH\",\n            \"/guilds/{guild_id}/integrations/{integration_id}\",\n            guild_id=guild_id,\n            integration_id=integration_id,\n        )\n\n        return self.request(r, json=payload)\n\n    def sync_integration(self, guild_id: Snowflake, integration_id: Snowflake) -> Response[None]:\n        r = Route(\n            \"POST\",\n            \"/guilds/{guild_id}/integrations/{integration_id}/sync\",\n            guild_id=guild_id,\n            integration_id=integration_id,\n        )\n\n        return self.request(r)\n\n    def delete_integration(\n        self, guild_id: Snowflake, integration_id: Snowflake, *, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/guilds/{guild_id}/integrations/{integration_id}\",\n            guild_id=guild_id,\n            integration_id=integration_id,\n        )\n\n        return self.request(r, reason=reason)\n\n    def get_audit_logs(\n        self,\n        guild_id: Snowflake,\n        limit: int = 100,\n        # only one of these two may be specified, otherwise `after` gets ignored\n        before: Snowflake | None = None,\n        after: Snowflake | None = None,\n        user_id: Snowflake | None = None,\n        action_type: audit_log.AuditLogEvent | None = None,\n    ) -> Response[audit_log.AuditLog]:\n        params: dict[str, Any] = {\"limit\": limit}\n        if before is not None:\n            params[\"before\"] = before\n        if after is not None:\n            params[\"after\"] = after\n        if user_id:\n            params[\"user_id\"] = user_id\n        if action_type:\n            params[\"action_type\"] = action_type\n\n        r = Route(\"GET\", \"/guilds/{guild_id}/audit-logs\", guild_id=guild_id)\n        return self.request(r, params=params)\n\n    def get_widget(self, guild_id: Snowflake) -> Response[widget.Widget]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/widget.json\", guild_id=guild_id))\n\n    def get_widget_settings(self, guild_id: Snowflake) -> Response[widget.WidgetSettings]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/widget\", guild_id=guild_id))\n\n    def edit_widget(\n        self, guild_id: Snowflake, payload: dict[str, Any], *, reason: str | None = None\n    ) -> Response[widget.WidgetSettings]:\n        return self.request(\n            Route(\"PATCH\", \"/guilds/{guild_id}/widget\", guild_id=guild_id),\n            json=payload,\n            reason=reason,\n        )\n\n    def widget_image_url(self, guild_id: Snowflake, *, style: str) -> str:\n        return str(\n            yarl.URL(Route.BASE)\n            .with_path(f\"/api/guilds/{guild_id}/widget.png\")\n            .with_query(style=style)\n        )\n\n    # Invite management\n\n    def create_invite(\n        self,\n        channel_id: Snowflake,\n        *,\n        reason: str | None = None,\n        max_age: int = 0,\n        max_uses: int = 0,\n        temporary: bool = False,\n        unique: bool = True,\n        target_type: invite.InviteTargetType | None = None,\n        target_user_id: Snowflake | None = None,\n        target_application_id: Snowflake | None = None,\n    ) -> Response[invite.Invite]:\n        r = Route(\"POST\", \"/channels/{channel_id}/invites\", channel_id=channel_id)\n        payload: dict[str, Any] = {\n            \"max_age\": max_age,\n            \"max_uses\": max_uses,\n            \"temporary\": temporary,\n            \"unique\": unique,\n        }\n\n        if target_type:\n            payload[\"target_type\"] = target_type\n\n        if target_user_id:\n            payload[\"target_user_id\"] = target_user_id\n\n        if target_application_id:\n            payload[\"target_application_id\"] = str(target_application_id)\n\n        return self.request(r, reason=reason, json=payload)\n\n    def get_invite(\n        self,\n        invite_id: str,\n        *,\n        with_counts: bool = True,\n        guild_scheduled_event_id: int | None = None,\n    ) -> Response[invite.Invite]:\n        params = {\n            \"with_counts\": int(with_counts),\n        }\n        if guild_scheduled_event_id:\n            params[\"guild_scheduled_event_id\"] = guild_scheduled_event_id\n\n        return self.request(\n            Route(\"GET\", \"/invites/{invite_id}\", invite_id=invite_id), params=params\n        )\n\n    def invites_from(self, guild_id: Snowflake) -> Response[list[invite.Invite]]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/invites\", guild_id=guild_id))\n\n    def invites_from_channel(self, channel_id: Snowflake) -> Response[list[invite.Invite]]:\n        return self.request(Route(\"GET\", \"/channels/{channel_id}/invites\", channel_id=channel_id))\n\n    def delete_invite(self, invite_id: str, *, reason: str | None = None) -> Response[None]:\n        return self.request(\n            Route(\"DELETE\", \"/invites/{invite_id}\", invite_id=invite_id), reason=reason\n        )\n\n    # Role management\n\n    def get_role(self, guild_id: Snowflake, role_id: Snowflake) -> Response[role.Role]:\n        return self.request(\n            Route(\"GET\", \"/guilds/{guild_id}/roles/{role_id}\", guild_id=guild_id, role_id=role_id)\n        )\n\n    def get_roles(self, guild_id: Snowflake) -> Response[list[role.Role]]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/roles\", guild_id=guild_id))\n\n    def get_role_member_counts(self, guild_id: Snowflake) -> Response[dict[Snowflake, int]]:\n        return self.request(\n            Route(\"GET\", \"/guilds/{guild_id}/roles/member-counts\", guild_id=guild_id)\n        )\n\n    def edit_role(\n        self,\n        guild_id: Snowflake,\n        role_id: Snowflake,\n        *,\n        reason: str | None = None,\n        **fields: Any,\n    ) -> Response[role.Role]:\n        r = Route(\"PATCH\", \"/guilds/{guild_id}/roles/{role_id}\", guild_id=guild_id, role_id=role_id)\n        valid_keys = (\n            \"name\",\n            \"permissions\",\n            \"color\",\n            \"colors\",\n            \"hoist\",\n            \"mentionable\",\n            \"icon\",\n            \"unicode_emoji\",\n            \"flags\",\n        )\n        payload = {k: v for k, v in fields.items() if k in valid_keys}\n        return self.request(r, json=payload, reason=reason)\n\n    def delete_role(\n        self, guild_id: Snowflake, role_id: Snowflake, *, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\", \"/guilds/{guild_id}/roles/{role_id}\", guild_id=guild_id, role_id=role_id\n        )\n        return self.request(r, reason=reason)\n\n    def replace_roles(\n        self,\n        user_id: Snowflake,\n        guild_id: Snowflake,\n        role_ids: list[int],\n        *,\n        reason: str | None = None,\n    ) -> Response[member.MemberWithUser]:\n        return self.edit_member(guild_id=guild_id, user_id=user_id, roles=role_ids, reason=reason)\n\n    def create_role(\n        self, guild_id: Snowflake, *, reason: str | None = None, **fields: Any\n    ) -> Response[role.Role]:\n        r = Route(\"POST\", \"/guilds/{guild_id}/roles\", guild_id=guild_id)\n        return self.request(r, json=fields, reason=reason)\n\n    def move_role_position(\n        self,\n        guild_id: Snowflake,\n        positions: list[guild.RolePositionUpdate],\n        *,\n        reason: str | None = None,\n    ) -> Response[list[role.Role]]:\n        r = Route(\"PATCH\", \"/guilds/{guild_id}/roles\", guild_id=guild_id)\n        return self.request(r, json=positions, reason=reason)\n\n    def add_role(\n        self,\n        guild_id: Snowflake,\n        user_id: Snowflake,\n        role_id: Snowflake,\n        *,\n        reason: str | None = None,\n    ) -> Response[None]:\n        r = Route(\n            \"PUT\",\n            \"/guilds/{guild_id}/members/{user_id}/roles/{role_id}\",\n            guild_id=guild_id,\n            user_id=user_id,\n            role_id=role_id,\n        )\n        return self.request(r, reason=reason)\n\n    def remove_role(\n        self,\n        guild_id: Snowflake,\n        user_id: Snowflake,\n        role_id: Snowflake,\n        *,\n        reason: str | None = None,\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/guilds/{guild_id}/members/{user_id}/roles/{role_id}\",\n            guild_id=guild_id,\n            user_id=user_id,\n            role_id=role_id,\n        )\n        return self.request(r, reason=reason)\n\n    def edit_channel_permissions(\n        self,\n        channel_id: Snowflake,\n        target: Snowflake,\n        allow: int,\n        deny: int,\n        type: channel.OverwriteType,\n        *,\n        reason: str | None = None,\n    ) -> Response[None]:\n        payload = {\"id\": target, \"allow\": allow, \"deny\": deny, \"type\": type}\n        r = Route(\n            \"PUT\",\n            \"/channels/{channel_id}/permissions/{target}\",\n            channel_id=channel_id,\n            target=target,\n        )\n        return self.request(r, json=payload, reason=reason)\n\n    def delete_channel_permissions(\n        self, channel_id: Snowflake, target: Snowflake, *, reason: str | None = None\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/channels/{channel_id}/permissions/{target}\",\n            channel_id=channel_id,\n            target=target,\n        )\n        return self.request(r, reason=reason)\n\n    # Voice management\n\n    def move_member(\n        self,\n        user_id: Snowflake,\n        guild_id: Snowflake,\n        channel_id: Snowflake,\n        *,\n        reason: str | None = None,\n    ) -> Response[member.MemberWithUser]:\n        return self.edit_member(\n            guild_id=guild_id, user_id=user_id, channel_id=channel_id, reason=reason\n        )\n\n    # Stage instance management\n\n    def get_stage_instance(self, channel_id: Snowflake) -> Response[channel.StageInstance]:\n        return self.request(Route(\"GET\", \"/stage-instances/{channel_id}\", channel_id=channel_id))\n\n    def create_stage_instance(\n        self, *, reason: str | None = None, **payload: Any\n    ) -> Response[channel.StageInstance]:\n        valid_keys = (\n            \"channel_id\",\n            \"topic\",\n            \"privacy_level\",\n            \"send_start_notification\",\n            \"guild_scheduled_event_id\",\n        )\n        payload = {k: v for k, v in payload.items() if k in valid_keys}\n\n        return self.request(Route(\"POST\", \"/stage-instances\"), json=payload, reason=reason)\n\n    def edit_stage_instance(\n        self, channel_id: Snowflake, *, reason: str | None = None, **payload: Any\n    ) -> Response[None]:\n        valid_keys = (\n            \"topic\",\n            \"privacy_level\",\n        )\n        payload = {k: v for k, v in payload.items() if k in valid_keys}\n\n        return self.request(\n            Route(\"PATCH\", \"/stage-instances/{channel_id}\", channel_id=channel_id),\n            json=payload,\n            reason=reason,\n        )\n\n    def delete_stage_instance(\n        self, channel_id: Snowflake, *, reason: str | None = None\n    ) -> Response[None]:\n        return self.request(\n            Route(\"DELETE\", \"/stage-instances/{channel_id}\", channel_id=channel_id), reason=reason\n        )\n\n    # Scheduled event management\n\n    def get_guild_scheduled_events(\n        self, guild_id: Snowflake, with_user_count: bool = False\n    ) -> Response[list[guild_scheduled_event.GuildScheduledEvent]]:\n        params = {\"with_user_count\": int(with_user_count)}\n        r = Route(\"GET\", \"/guilds/{guild_id}/scheduled-events\", guild_id=guild_id)\n        return self.request(r, params=params)\n\n    def create_guild_scheduled_event(\n        self,\n        guild_id: Snowflake,\n        *,\n        name: str,\n        privacy_level: int,\n        scheduled_start_time: str,\n        entity_type: int,\n        channel_id: Snowflake | None = None,\n        entity_metadata: dict[str, Any] | None = None,\n        scheduled_end_time: str | None = None,\n        description: str | None = None,\n        image: str | None = None,\n        reason: str | None = None,\n    ) -> Response[guild_scheduled_event.GuildScheduledEvent]:\n        r = Route(\"POST\", \"/guilds/{guild_id}/scheduled-events\", guild_id=guild_id)\n        payload: dict[str, Any] = {\n            \"name\": name,\n            \"privacy_level\": privacy_level,\n            \"scheduled_start_time\": scheduled_start_time,\n            \"entity_type\": entity_type,\n        }\n\n        if channel_id is not None:\n            payload[\"channel_id\"] = channel_id\n\n        if entity_metadata is not None:\n            payload[\"entity_metadata\"] = entity_metadata\n\n        if scheduled_end_time is not None:\n            payload[\"scheduled_end_time\"] = scheduled_end_time\n\n        if description is not None:\n            payload[\"description\"] = description\n\n        if image is not None:\n            payload[\"image\"] = image\n\n        return self.request(r, json=payload, reason=reason)\n\n    def get_guild_scheduled_event(\n        self, guild_id: Snowflake, event_id: Snowflake, with_user_count: bool = False\n    ) -> Response[guild_scheduled_event.GuildScheduledEvent]:\n        params = {\"with_user_count\": int(with_user_count)}\n        route = Route(\n            method=\"GET\",\n            path=\"/guilds/{guild_id}/scheduled-events/{event_id}\",\n            guild_id=guild_id,\n            event_id=event_id,\n        )\n        return self.request(route, params=params)\n\n    def edit_guild_scheduled_event(\n        self,\n        guild_id: Snowflake,\n        event_id: Snowflake,\n        *,\n        reason: str | None = None,\n        **fields: Any,\n    ) -> Response[guild_scheduled_event.GuildScheduledEvent]:\n        route = Route(\n            method=\"PATCH\",\n            path=\"/guilds/{guild_id}/scheduled-events/{event_id}\",\n            guild_id=guild_id,\n            event_id=event_id,\n        )\n\n        return self.request(route, json=fields, reason=reason)\n\n    def delete_guild_scheduled_event(\n        self, guild_id: Snowflake, event_id: Snowflake\n    ) -> Response[None]:\n        route = Route(\n            method=\"DELETE\",\n            path=\"/guilds/{guild_id}/scheduled-events/{event_id}\",\n            guild_id=guild_id,\n            event_id=event_id,\n        )\n        return self.request(route)\n\n    def get_guild_scheduled_event_users(\n        self,\n        guild_id: Snowflake,\n        event_id: Snowflake,\n        limit: int | None = None,\n        with_member: bool | None = None,\n        before: Snowflake | None = None,\n        after: Snowflake | None = None,\n    ) -> Response[list[guild_scheduled_event.GuildScheduledEventUser]]:\n        params: dict[str, Any] = {}\n\n        if limit is not None:\n            params[\"limit\"] = limit\n\n        if with_member is not None:\n            params[\"with_member\"] = int(with_member)\n\n        if before is not None:\n            params[\"before\"] = before\n\n        if after is not None:\n            params[\"after\"] = after\n\n        route = Route(\n            method=\"GET\",\n            path=\"/guilds/{guild_id}/scheduled-events/{event_id}/users\",\n            guild_id=guild_id,\n            event_id=event_id,\n        )\n        return self.request(route, params=params)\n\n    # Welcome screens\n\n    def get_guild_welcome_screen(\n        self, guild_id: Snowflake\n    ) -> Response[welcome_screen.WelcomeScreen]:\n        r = Route(\"GET\", \"/guilds/{guild_id}/welcome-screen\", guild_id=guild_id)\n        return self.request(r)\n\n    def edit_guild_welcome_screen(\n        self,\n        guild_id: Snowflake,\n        *,\n        reason: str | None = None,\n        **kwargs: Any,\n    ) -> Response[welcome_screen.WelcomeScreen]:\n        valid_keys = (\n            \"enabled\",\n            \"welcome_channels\",\n            \"description\",\n        )\n        payload = {k: v for k, v in kwargs.items() if k in valid_keys}\n\n        r = Route(\"PATCH\", \"/guilds/{guild_id}/welcome-screen\", guild_id=guild_id)\n        return self.request(r, json=payload, reason=reason)\n\n    # Auto moderation\n\n    def get_auto_moderation_rules(self, guild_id: Snowflake) -> Response[list[automod.AutoModRule]]:\n        return self.request(\n            Route(\"GET\", \"/guilds/{guild_id}/auto-moderation/rules\", guild_id=guild_id)\n        )\n\n    def get_auto_moderation_rule(\n        self, guild_id: Snowflake, rule_id: Snowflake\n    ) -> Response[automod.AutoModRule]:\n        return self.request(\n            Route(\n                \"GET\",\n                \"/guilds/{guild_id}/auto-moderation/rules/{rule_id}\",\n                guild_id=guild_id,\n                rule_id=rule_id,\n            )\n        )\n\n    def create_auto_moderation_rule(\n        self,\n        guild_id: Snowflake,\n        *,\n        name: str,\n        event_type: automod.AutoModEventType,\n        trigger_type: automod.AutoModTriggerType,\n        actions: list[automod.AutoModAction],\n        trigger_metadata: automod.AutoModTriggerMetadata | None = None,\n        enabled: bool | None = None,\n        exempt_roles: SnowflakeList | None = None,\n        exempt_channels: SnowflakeList | None = None,\n        reason: str | None = None,\n    ) -> Response[automod.AutoModRule]:\n        payload: automod.CreateAutoModRule = {\n            \"name\": name,\n            \"event_type\": event_type,\n            \"trigger_type\": trigger_type,\n            \"actions\": actions,\n        }\n\n        if trigger_metadata is not None:\n            payload[\"trigger_metadata\"] = trigger_metadata\n        if enabled is not None:\n            payload[\"enabled\"] = enabled\n        if exempt_roles is not None:\n            payload[\"exempt_roles\"] = exempt_roles\n        if exempt_channels is not None:\n            payload[\"exempt_channels\"] = exempt_channels\n\n        return self.request(\n            Route(\"POST\", \"/guilds/{guild_id}/auto-moderation/rules\", guild_id=guild_id),\n            json=payload,\n            reason=reason,\n        )\n\n    def edit_auto_moderation_rule(\n        self,\n        guild_id: Snowflake,\n        rule_id: Snowflake,\n        *,\n        reason: str | None = None,\n        **fields: Any,\n    ) -> Response[automod.AutoModRule]:\n        return self.request(\n            Route(\n                \"PATCH\",\n                \"/guilds/{guild_id}/auto-moderation/rules/{rule_id}\",\n                guild_id=guild_id,\n                rule_id=rule_id,\n            ),\n            json=fields,\n            reason=reason,\n        )\n\n    def delete_auto_moderation_rule(\n        self,\n        guild_id: Snowflake,\n        rule_id: Snowflake,\n        *,\n        reason: str | None = None,\n    ) -> Response[None]:\n        return self.request(\n            Route(\n                \"DELETE\",\n                \"/guilds/{guild_id}/auto-moderation/rules/{rule_id}\",\n                guild_id=guild_id,\n                rule_id=rule_id,\n            ),\n            reason=reason,\n        )\n\n    # Guild Onboarding\n\n    def get_guild_onboarding(self, guild_id: Snowflake) -> Response[onboarding.Onboarding]:\n        return self.request(Route(\"GET\", \"/guilds/{guild_id}/onboarding\", guild_id=guild_id))\n\n    # SKUs/Entitlements\n\n    def get_skus(self, application_id: Snowflake) -> Response[list[sku.SKU]]:\n        return self.request(\n            Route(\"GET\", \"/applications/{application_id}/skus\", application_id=application_id)\n        )\n\n    def get_entitlements(\n        self,\n        application_id: Snowflake,\n        *,\n        # if both are specified, `after` takes priority and `before` gets ignored\n        before: Snowflake | None = None,\n        after: Snowflake | None = None,\n        limit: int = 100,\n        user_id: Snowflake | None = None,\n        guild_id: Snowflake | None = None,\n        sku_ids: SnowflakeList | None = None,\n        exclude_ended: bool = False,\n        exclude_deleted: bool = False,\n    ) -> Response[list[entitlement.Entitlement]]:\n        params: dict[str, Any] = {\n            \"limit\": limit,\n            \"exclude_ended\": int(exclude_ended),\n            \"exclude_deleted\": int(exclude_deleted),\n        }\n        if before is not None:\n            params[\"before\"] = before\n        if after is not None:\n            params[\"after\"] = after\n        if user_id is not None:\n            params[\"user_id\"] = user_id\n        if guild_id is not None:\n            params[\"guild_id\"] = guild_id\n        if sku_ids:\n            params[\"sku_ids\"] = \",\".join(map(str, sku_ids))\n\n        r = Route(\n            \"GET\", \"/applications/{application_id}/entitlements\", application_id=application_id\n        )\n        return self.request(r, params=params)\n\n    def get_entitlement(\n        self, application_id: Snowflake, entitlement_id: int\n    ) -> Response[entitlement.Entitlement]:\n        return self.request(\n            Route(\n                \"GET\",\n                \"/applications/{application_id}/entitlements/{entitlement_id}\",\n                application_id=application_id,\n                entitlement_id=entitlement_id,\n            )\n        )\n\n    def get_subscriptions(\n        self,\n        sku_id: Snowflake,\n        *,\n        before: Snowflake | None = None,\n        after: Snowflake | None = None,\n        limit: int = 50,\n        user_id: Snowflake | None = None,\n    ) -> Response[list[subscription.Subscription]]:\n        params: dict[str, Any] = {\n            \"limit\": limit,\n        }\n        if before is not None:\n            params[\"before\"] = before\n        if after is not None:\n            params[\"after\"] = after\n        if user_id is not None:\n            params[\"user_id\"] = user_id\n\n        return self.request(\n            Route(\n                \"GET\",\n                \"/skus/{sku_id}/subscriptions\",\n                sku_id=sku_id,\n            ),\n            params=params,\n        )\n\n    def get_subscription(\n        self, sku_id: Snowflake, subscription_id: int\n    ) -> Response[subscription.Subscription]:\n        return self.request(\n            Route(\n                \"GET\",\n                \"/skus/{sku_id}/subscriptions/{subscription_id}\",\n                sku_id=sku_id,\n                subscription_id=subscription_id,\n            )\n        )\n\n    def create_test_entitlement(\n        self,\n        application_id: Snowflake,\n        sku_id: Snowflake,\n        owner_id: Snowflake,\n        *,\n        owner_type: Literal[1, 2],  # 1: guild, 2: user\n    ) -> Response[entitlement.Entitlement]:\n        payload: dict[str, Any] = {\n            \"sku_id\": sku_id,\n            \"owner_id\": owner_id,\n            \"owner_type\": owner_type,\n        }\n        return self.request(\n            Route(\n                \"POST\", \"/applications/{application_id}/entitlements\", application_id=application_id\n            ),\n            json=payload,\n        )\n\n    def delete_test_entitlement(\n        self,\n        application_id: Snowflake,\n        entitlement_id: Snowflake,\n    ) -> Response[None]:\n        return self.request(\n            Route(\n                \"DELETE\",\n                \"/applications/{application_id}/entitlements/{entitlement_id}\",\n                application_id=application_id,\n                entitlement_id=entitlement_id,\n            )\n        )\n\n    def consume_entitlement(\n        self,\n        application_id: Snowflake,\n        entitlement_id: Snowflake,\n    ) -> Response[None]:\n        return self.request(\n            Route(\n                \"POST\",\n                \"/applications/{application_id}/entitlements/{entitlement_id}/consume\",\n                application_id=application_id,\n                entitlement_id=entitlement_id,\n            )\n        )\n\n    # Application commands (global)\n\n    def get_global_commands(\n        self,\n        application_id: Snowflake,\n        *,\n        with_localizations: bool = True,\n    ) -> Response[list[interactions.ApplicationCommand]]:\n        params: dict[str, Any] = {}\n        # the API currently interprets any non-empty value as truthy\n        if with_localizations:\n            params[\"with_localizations\"] = int(with_localizations)\n\n        return self.request(\n            Route(\"GET\", \"/applications/{application_id}/commands\", application_id=application_id),\n            params=params,\n        )\n\n    def get_global_command(\n        self, application_id: Snowflake, command_id: Snowflake\n    ) -> Response[interactions.ApplicationCommand]:\n        r = Route(\n            \"GET\",\n            \"/applications/{application_id}/commands/{command_id}\",\n            application_id=application_id,\n            command_id=command_id,\n        )\n        return self.request(r)\n\n    def upsert_global_command(\n        self, application_id: Snowflake, payload: interactions.EditApplicationCommand\n    ) -> Response[interactions.ApplicationCommand]:\n        r = Route(\"POST\", \"/applications/{application_id}/commands\", application_id=application_id)\n        return self.request(r, json=payload)\n\n    def edit_global_command(\n        self,\n        application_id: Snowflake,\n        command_id: Snowflake,\n        payload: interactions.EditApplicationCommand,\n    ) -> Response[interactions.ApplicationCommand]:\n        r = Route(\n            \"PATCH\",\n            \"/applications/{application_id}/commands/{command_id}\",\n            application_id=application_id,\n            command_id=command_id,\n        )\n        return self.request(r, json=payload)\n\n    def delete_global_command(\n        self, application_id: Snowflake, command_id: Snowflake\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/applications/{application_id}/commands/{command_id}\",\n            application_id=application_id,\n            command_id=command_id,\n        )\n        return self.request(r)\n\n    def bulk_upsert_global_commands(\n        self, application_id: Snowflake, payload: list[interactions.EditApplicationCommand]\n    ) -> Response[list[interactions.ApplicationCommand]]:\n        r = Route(\"PUT\", \"/applications/{application_id}/commands\", application_id=application_id)\n        return self.request(r, json=payload)\n\n    # Application commands (guild)\n\n    def get_guild_commands(\n        self,\n        application_id: Snowflake,\n        guild_id: Snowflake,\n        *,\n        with_localizations: bool = True,\n    ) -> Response[list[interactions.ApplicationCommand]]:\n        params: dict[str, Any] = {}\n        # the API currently interprets any non-empty value as truthy\n        if with_localizations:\n            params[\"with_localizations\"] = int(with_localizations)\n\n        r = Route(\n            \"GET\",\n            \"/applications/{application_id}/guilds/{guild_id}/commands\",\n            application_id=application_id,\n            guild_id=guild_id,\n        )\n        return self.request(r, params=params)\n\n    def get_guild_command(\n        self,\n        application_id: Snowflake,\n        guild_id: Snowflake,\n        command_id: Snowflake,\n    ) -> Response[interactions.ApplicationCommand]:\n        r = Route(\n            \"GET\",\n            \"/applications/{application_id}/guilds/{guild_id}/commands/{command_id}\",\n            application_id=application_id,\n            guild_id=guild_id,\n            command_id=command_id,\n        )\n        return self.request(r)\n\n    def upsert_guild_command(\n        self,\n        application_id: Snowflake,\n        guild_id: Snowflake,\n        payload: interactions.EditApplicationCommand,\n    ) -> Response[interactions.ApplicationCommand]:\n        r = Route(\n            \"POST\",\n            \"/applications/{application_id}/guilds/{guild_id}/commands\",\n            application_id=application_id,\n            guild_id=guild_id,\n        )\n        return self.request(r, json=payload)\n\n    def edit_guild_command(\n        self,\n        application_id: Snowflake,\n        guild_id: Snowflake,\n        command_id: Snowflake,\n        payload: interactions.EditApplicationCommand,\n    ) -> Response[interactions.ApplicationCommand]:\n        r = Route(\n            \"PATCH\",\n            \"/applications/{application_id}/guilds/{guild_id}/commands/{command_id}\",\n            application_id=application_id,\n            guild_id=guild_id,\n            command_id=command_id,\n        )\n        return self.request(r, json=payload)\n\n    def delete_guild_command(\n        self,\n        application_id: Snowflake,\n        guild_id: Snowflake,\n        command_id: Snowflake,\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/applications/{application_id}/guilds/{guild_id}/commands/{command_id}\",\n            application_id=application_id,\n            guild_id=guild_id,\n            command_id=command_id,\n        )\n        return self.request(r)\n\n    def bulk_upsert_guild_commands(\n        self,\n        application_id: Snowflake,\n        guild_id: Snowflake,\n        payload: list[interactions.EditApplicationCommand],\n    ) -> Response[list[interactions.ApplicationCommand]]:\n        r = Route(\n            \"PUT\",\n            \"/applications/{application_id}/guilds/{guild_id}/commands\",\n            application_id=application_id,\n            guild_id=guild_id,\n        )\n        return self.request(r, json=payload)\n\n    # Interaction responses\n\n    def _edit_webhook_helper(\n        self,\n        route: Route,\n        file: File | None = None,\n        content: str | None = None,\n        embeds: list[embed.Embed] | None = None,\n        allowed_mentions: message.AllowedMentions | None = None,\n        attachments: list[Attachment] | None = None,\n    ) -> Response[message.Message]:\n        # TODO: this does not work how it should (e.g. `embeds=[]` is ignored).\n        #       This method (or rather its calling methods) is completely unused, and hence likely untested\n\n        payload: dict[str, Any] = {}\n        if content:\n            payload[\"content\"] = content\n        if embeds:\n            payload[\"embeds\"] = embeds\n        if allowed_mentions:\n            payload[\"allowed_mentions\"] = allowed_mentions\n        if attachments:\n            payload[\"attachments\"] = attachments\n\n        if file:\n            multipart = to_multipart_with_attachments(payload, [file])\n            return self.request(route, form=multipart, files=[file])\n        return self.request(route, json=payload)\n\n    def create_interaction_response(\n        self,\n        interaction_id: Snowflake,\n        token: str,\n        *,\n        type: InteractionResponseType,\n        data: interactions.InteractionCallbackData | None = None,\n    ) -> Response[None]:\n        r = Route(\n            \"POST\",\n            \"/interactions/{interaction_id}/{interaction_token}/callback\",\n            interaction_id=interaction_id,\n            interaction_token=token,\n        )\n        payload: dict[str, Any] = {\n            \"type\": type,\n        }\n\n        if data is not None:\n            payload[\"data\"] = data\n\n        return self.request(r, json=payload)\n\n    def get_original_interaction_response(\n        self,\n        application_id: Snowflake,\n        token: str,\n    ) -> Response[message.Message]:\n        r = Route(\n            \"GET\",\n            \"/webhooks/{application_id}/{interaction_token}/messages/@original\",\n            application_id=application_id,\n            interaction_token=token,\n        )\n        return self.request(r)\n\n    def edit_original_interaction_response(\n        self,\n        application_id: Snowflake,\n        token: str,\n        file: File | None = None,\n        content: str | None = None,\n        embeds: list[embed.Embed] | None = None,\n        allowed_mentions: message.AllowedMentions | None = None,\n        attachments: list[Attachment] | None = None,\n    ) -> Response[message.Message]:\n        r = Route(\n            \"PATCH\",\n            \"/webhooks/{application_id}/{interaction_token}/messages/@original\",\n            application_id=application_id,\n            interaction_token=token,\n        )\n        return self._edit_webhook_helper(\n            r,\n            file=file,\n            content=content,\n            embeds=embeds,\n            allowed_mentions=allowed_mentions,\n            attachments=attachments,\n        )\n\n    def delete_original_interaction_response(\n        self, application_id: Snowflake, token: str\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/webhooks/{application_id}/{interaction_token}/messages/@original\",\n            application_id=application_id,\n            interaction_token=token,\n        )\n        return self.request(r)\n\n    def create_followup_message(\n        self,\n        application_id: Snowflake,\n        token: str,\n        files: list[File] | None = None,\n        content: str | None = None,\n        tts: bool = False,\n        embeds: list[embed.Embed] | None = None,\n        allowed_mentions: message.AllowedMentions | None = None,\n    ) -> Response[message.Message]:\n        r = Route(\n            \"POST\",\n            \"/webhooks/{application_id}/{interaction_token}\",\n            application_id=application_id,\n            interaction_token=token,\n        )\n        if files is None:\n            files = []\n        return self.send_multipart_helper(\n            r,\n            content=content,\n            files=files,\n            tts=tts,\n            embeds=embeds,\n            allowed_mentions=allowed_mentions,\n        )\n\n    def edit_followup_message(\n        self,\n        application_id: Snowflake,\n        token: str,\n        message_id: Snowflake,\n        file: File | None = None,\n        content: str | None = None,\n        embeds: list[embed.Embed] | None = None,\n        allowed_mentions: message.AllowedMentions | None = None,\n        attachments: list[Attachment] | None = None,\n    ) -> Response[message.Message]:\n        r = Route(\n            \"PATCH\",\n            \"/webhooks/{application_id}/{interaction_token}/messages/{message_id}\",\n            application_id=application_id,\n            interaction_token=token,\n            message_id=message_id,\n        )\n        return self._edit_webhook_helper(\n            r,\n            file=file,\n            content=content,\n            embeds=embeds,\n            allowed_mentions=allowed_mentions,\n            attachments=attachments,\n        )\n\n    def delete_followup_message(\n        self, application_id: Snowflake, token: str, message_id: Snowflake\n    ) -> Response[None]:\n        r = Route(\n            \"DELETE\",\n            \"/webhooks/{application_id}/{interaction_token}/messages/{message_id}\",\n            application_id=application_id,\n            interaction_token=token,\n            message_id=message_id,\n        )\n        return self.request(r)\n\n    def get_guild_application_command_permissions(\n        self,\n        application_id: Snowflake,\n        guild_id: Snowflake,\n    ) -> Response[list[interactions.GuildApplicationCommandPermissions]]:\n        r = Route(\n            \"GET\",\n            \"/applications/{application_id}/guilds/{guild_id}/commands/permissions\",\n            application_id=application_id,\n            guild_id=guild_id,\n        )\n        return self.request(r)\n\n    def get_application_command_permissions(\n        self,\n        application_id: Snowflake,\n        guild_id: Snowflake,\n        command_id: Snowflake,\n    ) -> Response[interactions.GuildApplicationCommandPermissions]:\n        r = Route(\n            \"GET\",\n            \"/applications/{application_id}/guilds/{guild_id}/commands/{command_id}/permissions\",\n            application_id=application_id,\n            guild_id=guild_id,\n            command_id=command_id,\n        )\n        return self.request(r)\n\n    # Soundboard\n\n    def get_default_soundboard_sounds(self) -> Response[list[soundboard.SoundboardSound]]:\n        return self.request(Route(\"GET\", \"/soundboard-default-sounds\"))\n\n    def get_guild_soundboard_sound(\n        self, guild_id: Snowflake, sound_id: Snowflake\n    ) -> Response[soundboard.GuildSoundboardSound]:\n        return self.request(\n            Route(\n                \"GET\",\n                \"/guilds/{guild_id}/soundboard-sounds/{sound_id}\",\n                guild_id=guild_id,\n                sound_id=sound_id,\n            )\n        )\n\n    def get_guild_soundboard_sounds(\n        self, guild_id: Snowflake\n    ) -> Response[soundboard.ListGuildSoundboardSounds]:\n        return self.request(\n            Route(\n                \"GET\",\n                \"/guilds/{guild_id}/soundboard-sounds\",\n                guild_id=guild_id,\n            )\n        )\n\n    def create_guild_soundboard_sound(\n        self,\n        guild_id: Snowflake,\n        *,\n        name: str,\n        sound: str | None,\n        volume: float | None = None,\n        emoji_id: Snowflake | None = None,\n        emoji_name: str | None = None,\n        reason: str | None = None,\n    ) -> Response[soundboard.GuildSoundboardSound]:\n        payload: dict[str, Any] = {\n            \"name\": name,\n            \"sound\": sound,\n        }\n\n        if volume is not None:\n            payload[\"volume\"] = volume\n        if emoji_id is not None:\n            payload[\"emoji_id\"] = emoji_id\n        if emoji_name is not None:\n            payload[\"emoji_name\"] = emoji_name\n\n        return self.request(\n            Route(\"POST\", \"/guilds/{guild_id}/soundboard-sounds\", guild_id=guild_id),\n            json=payload,\n            reason=reason,\n        )\n\n    def edit_guild_soundboard_sound(\n        self,\n        guild_id: Snowflake,\n        sound_id: Snowflake,\n        *,\n        reason: str | None = None,\n        **fields: Any,\n    ) -> Response[soundboard.GuildSoundboardSound]:\n        valid_keys = (\n            \"name\",\n            \"volume\",\n            \"emoji_id\",\n            \"emoji_name\",\n        )\n        payload = {k: v for k, v in fields.items() if k in valid_keys}\n        return self.request(\n            Route(\n                \"PATCH\",\n                \"/guilds/{guild_id}/soundboard-sounds/{sound_id}\",\n                guild_id=guild_id,\n                sound_id=sound_id,\n            ),\n            json=payload,\n            reason=reason,\n        )\n\n    def delete_guild_soundboard_sound(\n        self,\n        guild_id: Snowflake,\n        sound_id: Snowflake,\n        *,\n        reason: str | None = None,\n    ) -> Response[None]:\n        return self.request(\n            Route(\n                \"DELETE\",\n                \"/guilds/{guild_id}/soundboard-sounds/{sound_id}\",\n                guild_id=guild_id,\n                sound_id=sound_id,\n            ),\n            reason=reason,\n        )\n\n    def send_soundboard_sound(\n        self,\n        channel_id: Snowflake,\n        sound_id: Snowflake,\n        *,\n        source_guild_id: Snowflake | None = None,\n    ) -> Response[None]:\n        payload: dict[str, Any] = {\n            \"sound_id\": sound_id,\n        }\n        if source_guild_id is not None:\n            payload[\"source_guild_id\"] = source_guild_id\n\n        return self.request(\n            Route(\"POST\", \"/channels/{channel_id}/send-soundboard-sound\", channel_id=channel_id),\n            json=payload,\n        )\n\n    # Misc\n\n    def get_voice_regions(self) -> Response[list[voice.VoiceRegion]]:\n        return self.request(Route(\"GET\", \"/voice/regions\"))\n\n    def application_info(self) -> Response[appinfo.AppInfo]:\n        return self.request(Route(\"GET\", \"/oauth2/applications/@me\"))\n\n    def edit_application_info(self, **fields: Any) -> Response[appinfo.AppInfo]:\n        return self.request(Route(\"PATCH\", \"/applications/@me\"), json=fields)\n\n    def get_application_role_connection_metadata_records(\n        self, application_id: Snowflake\n    ) -> Response[list[application_role_connection.ApplicationRoleConnectionMetadata]]:\n        return self.request(\n            Route(\n                \"GET\",\n                \"/applications/{application_id}/role-connections/metadata\",\n                application_id=application_id,\n            )\n        )\n\n    def edit_application_role_connection_metadata_records(\n        self,\n        application_id: Snowflake,\n        records: Sequence[application_role_connection.ApplicationRoleConnectionMetadata],\n    ) -> Response[list[application_role_connection.ApplicationRoleConnectionMetadata]]:\n        return self.request(\n            Route(\n                \"PUT\",\n                \"/applications/{application_id}/role-connections/metadata\",\n                application_id=application_id,\n            ),\n            json=records,\n        )\n\n    async def get_gateway(self, *, encoding: str = \"json\", zlib: bool = True) -> str:\n        try:\n            data: gateway.Gateway = await self.request(Route(\"GET\", \"/gateway\"))\n        except HTTPException as exc:\n            raise GatewayNotFound from exc\n\n        return self._format_gateway_url(data[\"url\"], encoding=encoding, zlib=zlib)\n\n    async def get_bot_gateway(\n        self, *, encoding: str = \"json\", zlib: bool = True\n    ) -> tuple[int, str, gateway.SessionStartLimit]:\n        try:\n            data: gateway.GatewayBot = await self.request(Route(\"GET\", \"/gateway/bot\"))\n        except HTTPException as exc:\n            raise GatewayNotFound from exc\n\n        return (\n            data[\"shards\"],\n            self._format_gateway_url(data[\"url\"], encoding=encoding, zlib=zlib),\n            data[\"session_start_limit\"],\n        )\n\n    @staticmethod\n    def _format_gateway_url(url: str, *, encoding: str, zlib: bool) -> str:\n        _url = yarl.URL(url)\n        params = _url.query.copy()\n        params[\"v\"] = str(_API_VERSION)\n        params[\"encoding\"] = encoding\n        if zlib:\n            params[\"compress\"] = \"zlib-stream\"\n        else:\n            params.popall(\"compress\", None)\n        return str(_url.with_query(params))\n\n    def get_user(self, user_id: Snowflake) -> Response[user.User]:\n        return self.request(Route(\"GET\", \"/users/{user_id}\", user_id=user_id))", "n_imports_parsed": 2, "n_files_resolved": 1, "n_chars_extracted": 97564}, "tests/test_flags.py::147": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": [], "enclosing_function": "test_flag_value_xor", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_colour.py::61": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Color", "Colour"], "enclosing_function": "test_alias", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/tasks/test_loops.py::66": {"resolved_imports": ["disnake/ext/commands/__init__.py", "disnake/ext/tasks/__init__.py"], "used_names": ["Any", "LF", "Loop", "commands", "loop"], "enclosing_function": "test_inheritance", "extracted_code": "# Source: disnake/ext/tasks/__init__.py\nLF = TypeVar(\"LF\", bound=Callable[..., Coroutine[Any, Any, Any]])\n\nclass Loop(Generic[LF]):\n    \"\"\"A background task helper that abstracts the loop and reconnection logic for you.\n\n    The main interface to create this is through :func:`loop`.\n    \"\"\"\n\n    def __init__(\n        self,\n        coro: LF,\n        *,\n        seconds: float = 0,\n        minutes: float = 0,\n        hours: float = 0,\n        time: datetime.time | Sequence[datetime.time] = MISSING,\n        count: int | None = None,\n        reconnect: bool = True,\n        loop: asyncio.AbstractEventLoop = MISSING,\n    ) -> None:\n        \"\"\".. note:\n        If you overwrite ``__init__`` arguments, make sure to redefine .clone too.\n        \"\"\"\n        self.coro: LF = coro\n        self.reconnect: bool = reconnect\n        self.loop: asyncio.AbstractEventLoop = loop\n        self.count: int | None = count\n        self._current_loop = 0\n        self._handle: SleepHandle = MISSING\n        self._task: asyncio.Task[None] = MISSING\n        self._injected: Any = None\n        self._valid_exception = (\n            OSError,\n            disnake.GatewayNotFound,\n            disnake.ConnectionClosed,\n            aiohttp.ClientError,\n            asyncio.TimeoutError,\n        )\n\n        self._before_loop = None\n        self._after_loop = None\n        self._is_being_cancelled = False\n        self._has_failed = False\n        self._stop_next_iteration = False\n\n        if self.count is not None and self.count <= 0:\n            msg = \"count must be greater than 0 or None.\"\n            raise ValueError(msg)\n\n        self.change_interval(seconds=seconds, minutes=minutes, hours=hours, time=time)\n        self._last_iteration_failed = False\n        self._last_iteration: datetime.datetime = MISSING\n        self._next_iteration = None\n\n        if not iscoroutinefunction(self.coro):\n            msg = f\"Expected coroutine function, not {type(self.coro).__name__!r}.\"\n            raise TypeError(msg)\n\n    async def _call_loop_function(self, name: str, *args: Any, **kwargs: Any) -> None:\n        coro = getattr(self, \"_\" + name)\n        if coro is None:\n            return\n\n        if self._injected is not None:\n            await coro(self._injected, *args, **kwargs)\n        else:\n            await coro(*args, **kwargs)\n\n    def _try_sleep_until(self, dt: datetime.datetime) -> asyncio.Future[bool]:\n        self._handle = SleepHandle(dt=dt, loop=self.loop)\n        return self._handle.wait()\n\n    async def _loop(self, *args: Any, **kwargs: Any) -> None:\n        backoff = ExponentialBackoff()\n        await self._call_loop_function(\"before_loop\")\n        self._last_iteration_failed = False\n        if self._time is not MISSING:\n            # the time index should be prepared every time the internal loop is started\n            self._prepare_time_index()\n            self._next_iteration = self._get_next_sleep_time()\n        else:\n            self._next_iteration = utcnow()\n        try:\n            await self._try_sleep_until(self._next_iteration)\n            while True:\n                if not self._last_iteration_failed:\n                    self._last_iteration = self._next_iteration\n                    self._next_iteration = self._get_next_sleep_time()\n                try:\n                    await self.coro(*args, **kwargs)\n                    self._last_iteration_failed = False\n                except self._valid_exception:\n                    self._last_iteration_failed = True\n                    if not self.reconnect:\n                        raise\n                    await asyncio.sleep(backoff.delay())\n                else:\n                    await self._try_sleep_until(self._next_iteration)\n\n                    if self._stop_next_iteration:\n                        return\n\n                    now = utcnow()\n                    if now > self._next_iteration:\n                        self._next_iteration = now\n                        if self._time is not MISSING:\n                            self._prepare_time_index(now)\n\n                    self._current_loop += 1\n                    if self._current_loop == self.count:\n                        break\n\n        except asyncio.CancelledError:\n            self._is_being_cancelled = True\n            raise\n        except Exception as exc:\n            self._has_failed = True\n            await self._call_loop_function(\"error\", exc)\n            raise\n        finally:\n            await self._call_loop_function(\"after_loop\")\n            self._handle.cancel()\n            self._is_being_cancelled = False\n            self._current_loop = 0\n            self._stop_next_iteration = False\n            self._has_failed = False\n\n    def __get__(self, obj: T, objtype: type[T]) -> Self:\n        if obj is None:\n            return self\n        clone = self.clone()\n        clone._injected = obj\n        setattr(obj, self.coro.__name__, clone)\n        return clone\n\n    def clone(self) -> Self:\n        instance = type(self)(\n            self.coro,\n            seconds=self._seconds,\n            hours=self._hours,\n            minutes=self._minutes,\n            time=self._time,\n            count=self.count,\n            reconnect=self.reconnect,\n            loop=self.loop,\n        )\n        instance._before_loop = self._before_loop\n        instance._after_loop = self._after_loop\n        instance._error = self._error\n        instance._injected = self._injected\n        return instance\n\n    @property\n    def seconds(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of seconds\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._seconds is not MISSING:\n            return self._seconds\n        return None\n\n    @property\n    def minutes(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of minutes\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._minutes is not MISSING:\n            return self._minutes\n        return None\n\n    @property\n    def hours(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of hours\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._hours is not MISSING:\n            return self._hours\n        return None\n\n    @property\n    def time(self) -> list[datetime.time] | None:\n        r\"\"\":class:`list`\\[:class:`datetime.time`] | :data:`None`: Read-only list for the exact times this loop runs at.\n        :data:`None` if relative times were passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._time is not MISSING:\n            return self._time.copy()\n        return None\n\n    @property\n    def current_loop(self) -> int:\n        \"\"\":class:`int`: The current iteration of the loop.\"\"\"\n        return self._current_loop\n\n    @property\n    def next_iteration(self) -> datetime.datetime | None:\n        \"\"\":class:`datetime.datetime` | :data:`None`: When the next iteration of the loop will occur.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self._task is MISSING or (self._task and self._task.done()) or self._stop_next_iteration:\n            return None\n        return self._next_iteration\n\n    async def __call__(self, *args: Any, **kwargs: Any) -> Any:\n        \"\"\"|coro|\n\n        Calls the internal callback that the task holds.\n\n        .. versionadded:: 1.6\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n        \"\"\"\n        if self._injected is not None:\n            args = (self._injected, *args)\n\n        return await self.coro(*args, **kwargs)\n\n    def start(self, *args: Any, **kwargs: Any) -> asyncio.Task[None]:\n        \"\"\"Starts the internal task in the event loop.\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n\n        Raises\n        ------\n        RuntimeError\n            A task has already been launched and is running.\n\n        Returns\n        -------\n        :class:`asyncio.Task`\n            The task that has been created.\n        \"\"\"\n        if self._task is not MISSING and not self._task.done():\n            msg = \"Task is already launched and is not completed.\"\n            raise RuntimeError(msg)\n\n        if self._injected is not None:\n            args = (self._injected, *args)\n\n        if self.loop is MISSING:\n            self.loop = disnake.utils.get_event_loop()\n\n        self._task = self.loop.create_task(self._loop(*args, **kwargs))\n        return self._task\n\n    def stop(self) -> None:\n        r\"\"\"Gracefully stops the task from running.\n\n        Unlike :meth:`cancel`\\, this allows the task to finish its\n        current iteration before gracefully exiting.\n\n        .. note::\n\n            If the internal function raises an error that can be\n            handled before finishing then it will retry until\n            it succeeds.\n\n            If this is undesirable, either remove the error handling\n            before stopping via :meth:`clear_exception_types` or\n            use :meth:`cancel` instead.\n\n        .. versionadded:: 1.2\n        \"\"\"\n        if self._task is not MISSING and not self._task.done():\n            self._stop_next_iteration = True\n\n    def _can_be_cancelled(self) -> bool:\n        return bool(not self._is_being_cancelled and self._task and not self._task.done())\n\n    def cancel(self) -> None:\n        \"\"\"Cancels the internal task, if it is running.\"\"\"\n        if self._can_be_cancelled():\n            self._task.cancel()\n\n    def restart(self, *args: Any, **kwargs: Any) -> None:\n        \"\"\"A convenience method to restart the internal task.\n\n        .. note::\n\n            Due to the way this function works, the task is not\n            returned like :meth:`start`.\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n        \"\"\"\n\n        def restart_when_over(fut: Any, *, args: Any = args, kwargs: Any = kwargs) -> None:\n            self._task.remove_done_callback(restart_when_over)\n            self.start(*args, **kwargs)\n\n        if self._can_be_cancelled():\n            self._task.add_done_callback(restart_when_over)\n            self._task.cancel()\n\n    def add_exception_type(self, *exceptions: type[BaseException]) -> None:\n        r\"\"\"Adds exception types to be handled during the reconnect logic.\n\n        By default the exception types handled are those handled by\n        :meth:`disnake.Client.connect`\\, which includes a lot of internet disconnection\n        errors.\n\n        This function is useful if you're interacting with a 3rd party library that\n        raises its own set of exceptions.\n\n        Parameters\n        ----------\n        *exceptions: :class:`type`\\[:class:`BaseException`]\n            An argument list of exception classes to handle.\n\n        Raises\n        ------\n        TypeError\n            An exception passed is either not a class or not inherited from :class:`BaseException`.\n        \"\"\"\n        for exc in exceptions:\n            if not inspect.isclass(exc):\n                msg = f\"{exc!r} must be a class.\"\n                raise TypeError(msg)\n            if not issubclass(exc, BaseException):\n                msg = f\"{exc!r} must inherit from BaseException.\"\n                raise TypeError(msg)\n\n        self._valid_exception = (*self._valid_exception, *exceptions)\n\n    def clear_exception_types(self) -> None:\n        \"\"\"Removes all exception types that are handled.\n\n        .. note::\n\n            This operation obviously cannot be undone!\n        \"\"\"\n        self._valid_exception = ()\n\n    def remove_exception_type(self, *exceptions: type[BaseException]) -> bool:\n        r\"\"\"Removes exception types from being handled during the reconnect logic.\n\n        Parameters\n        ----------\n        *exceptions: :class:`type`\\[:class:`BaseException`]\n            An argument list of exception classes to handle.\n\n        Returns\n        -------\n        :class:`bool`\n            Whether all exceptions were successfully removed.\n        \"\"\"\n        old_length = len(self._valid_exception)\n        self._valid_exception = tuple(x for x in self._valid_exception if x not in exceptions)\n        return len(self._valid_exception) == old_length - len(exceptions)\n\n    def get_task(self) -> asyncio.Task[None] | None:\n        \"\"\"Fetches the internal task or :data:`None` if there isn't one running.\n\n        :return type: :class:`asyncio.Task` | :data:`None`\n        \"\"\"\n        return self._task if self._task is not MISSING else None\n\n    def is_being_cancelled(self) -> bool:\n        \"\"\"Whether the task is being cancelled.\n\n        :return type: :class:`bool`\n        \"\"\"\n        return self._is_being_cancelled\n\n    def failed(self) -> bool:\n        \"\"\"Whether the internal task has failed.\n\n        .. versionadded:: 1.2\n\n        :return type: :class:`bool`\n        \"\"\"\n        return self._has_failed\n\n    def is_running(self) -> bool:\n        \"\"\"Check if the task is currently running.\n\n        .. versionadded:: 1.4\n\n        :return type: :class:`bool`\n        \"\"\"\n        return not bool(self._task.done()) if self._task is not MISSING else False\n\n    async def _error(self, *args: Any) -> None:\n        exception: Exception = args[-1]\n        print(\n            f\"Unhandled exception in internal background task {self.coro.__name__!r}.\",\n            file=sys.stderr,\n        )\n        traceback.print_exception(\n            type(exception), exception, exception.__traceback__, file=sys.stderr\n        )\n\n    def before_loop(self, coro: FT) -> FT:\n        \"\"\"A decorator that registers a coroutine function to be called before the loop starts running.\n\n        This is useful if you want to wait for some bot state before the loop starts,\n        such as :meth:`disnake.Client.wait_until_ready`.\n\n        The coroutine must take no arguments (except ``self`` in a class context).\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register before the loop runs.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._before_loop = coro\n        return coro\n\n    def after_loop(self, coro: FT) -> FT:\n        \"\"\"A decorator that register a coroutine function to be called after the loop finished running.\n\n        The coroutine must take no arguments (except ``self`` in a class context).\n\n        .. note::\n\n            This coroutine is called even during cancellation. If it is desirable\n            to tell apart whether something was cancelled or not, check to see\n            whether :meth:`is_being_cancelled` is ``True`` or not.\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register after the loop finishes.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._after_loop = coro\n        return coro\n\n    def error(self, coro: ET) -> ET:\n        \"\"\"A decorator that registers a coroutine function to be called if the task encounters an unhandled exception.\n\n        The coroutine must take only one argument the exception raised (except ``self`` in a class context).\n\n        By default this prints to :data:`sys.stderr` however it could be\n        overridden to have a different implementation.\n\n        .. versionadded:: 1.4\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register in the event of an unhandled exception.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._error = coro  # pyright: ignore[reportAttributeAccessIssue]\n        return coro\n\n    def _get_next_sleep_time(self) -> datetime.datetime:\n        if self._sleep is not MISSING:\n            return self._last_iteration + datetime.timedelta(seconds=self._sleep)\n\n        if self._time_index >= len(self._time):\n            self._time_index = 0\n            if self._current_loop == 0:\n                # if we're at the last index on the first iteration, we need to sleep until tomorrow\n                return datetime.datetime.combine(\n                    utcnow() + datetime.timedelta(days=1),\n                    self._time[0],\n                )\n\n        next_time = self._time[self._time_index]\n\n        if self._current_loop == 0:\n            self._time_index += 1\n            if next_time > utcnow().timetz():\n                return datetime.datetime.combine(utcnow(), next_time)\n            else:\n                return datetime.datetime.combine(\n                    utcnow() + datetime.timedelta(days=1),\n                    next_time,\n                )\n\n        next_date = self._last_iteration\n        if next_time < next_date.timetz():\n            next_date += datetime.timedelta(days=1)\n\n        self._time_index += 1\n        return datetime.datetime.combine(next_date, next_time)\n\n    def _prepare_time_index(self, now: datetime.datetime = MISSING) -> None:\n        # now kwarg should be a datetime.datetime representing the time \"now\"\n        # to calculate the next time index from\n\n        # pre-condition: self._time is set\n        time_now = (now if now is not MISSING else utcnow().replace(microsecond=0)).timetz()\n        for idx, time in enumerate(self._time):\n            if time >= time_now:\n                self._time_index = idx\n                break\n        else:\n            self._time_index = 0\n\n    def _get_time_parameter(\n        self,\n        time: datetime.time | Sequence[datetime.time],\n        *,\n        dt: type[datetime.time] = datetime.time,\n        utc: datetime.timezone = datetime.timezone.utc,\n    ) -> list[datetime.time]:\n        if isinstance(time, dt):\n            inner = time if time.tzinfo is not None else time.replace(tzinfo=utc)\n            return [inner]\n        if not isinstance(time, Sequence):\n            msg = f\"Expected datetime.time or a sequence of datetime.time for ``time``, received {type(time)!r} instead.\"\n            raise TypeError(msg)\n        if not time:\n            msg = \"time parameter must not be an empty sequence.\"\n            raise ValueError(msg)\n\n        ret: list[datetime.time] = []\n        for index, t in enumerate(time):\n            if not isinstance(t, dt):\n                msg = f\"Expected a sequence of {dt!r} for ``time``, received {type(t).__name__!r} at index {index} instead.\"\n                raise TypeError(msg)\n            ret.append(t if t.tzinfo is not None else t.replace(tzinfo=utc))\n\n        return sorted(set(ret))  # de-dupe and sort times\n\n    def change_interval(\n        self,\n        *,\n        seconds: float = 0,\n        minutes: float = 0,\n        hours: float = 0,\n        time: datetime.time | Sequence[datetime.time] = MISSING,\n    ) -> None:\n        r\"\"\"Changes the interval for the sleep time.\n\n        .. versionadded:: 1.2\n\n        Parameters\n        ----------\n        seconds: :class:`float`\n            The number of seconds between every iteration.\n        minutes: :class:`float`\n            The number of minutes between every iteration.\n        hours: :class:`float`\n            The number of hours between every iteration.\n        time: :class:`datetime.time` | :class:`~collections.abc.Sequence`\\[:class:`datetime.time`]\n            The exact times to run this loop at. Either a non-empty list or a single\n            value of :class:`datetime.time` should be passed.\n            This cannot be used in conjunction with the relative time parameters.\n\n            .. versionadded:: 2.0\n\n            .. note::\n\n                Duplicate times will be ignored, and only run once.\n\n        Raises\n        ------\n        ValueError\n            An invalid value was given.\n        TypeError\n            An invalid value for the ``time`` parameter was passed, or the\n            ``time`` parameter was passed in conjunction with relative time parameters.\n        \"\"\"\n        if time is MISSING:\n            seconds = seconds or 0\n            minutes = minutes or 0\n            hours = hours or 0\n            sleep = seconds + (minutes * 60.0) + (hours * 3600.0)\n            if sleep < 0:\n                msg = \"Total number of seconds cannot be less than zero.\"\n                raise ValueError(msg)\n\n            self._sleep = sleep\n            self._seconds = float(seconds)\n            self._hours = float(hours)\n            self._minutes = float(minutes)\n            self._time: list[datetime.time] = MISSING\n        else:\n            if any((seconds, minutes, hours)):\n                msg = \"Cannot mix explicit time with relative time\"\n                raise TypeError(msg)\n            self._time = self._get_time_parameter(time)\n            self._sleep = self._seconds = self._minutes = self._hours = MISSING\n\n        # `_last_iteration` can be missing if `change_interval` gets called in `before_loop` or\n        # before the event loop ticks after `start()`\n        if self.is_running() and self._last_iteration is not MISSING:\n            if self._time is not MISSING:\n                # prepare the next time index starting from after the last iteration\n                self._prepare_time_index(now=self._last_iteration)\n\n            self._next_iteration = self._get_next_sleep_time()\n            if not self._handle.done():\n                # the loop is sleeping, recalculate based on new interval\n                self._handle.recalculate(self._next_iteration)\n\ndef loop(\n    *,\n    seconds: float = ...,\n    minutes: float = ...,\n    hours: float = ...,\n    time: datetime.time | Sequence[datetime.time] = ...,\n    count: int | None = None,\n    reconnect: bool = True,\n    loop: asyncio.AbstractEventLoop = ...,\n) -> Callable[[LF], Loop[LF]]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, P], L_co], *_: P.args, **kwargs: P.kwargs\n) -> Callable[[LF], L_co]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, ...], L_co] = Loop[Any],\n    **kwargs: Any,\n) -> Callable[[LF], L_co]:\n    r\"\"\"A decorator that schedules a task in the background for you with\n    optional reconnect logic. The decorator returns a :class:`Loop`.\n\n    Parameters\n    ----------\n    cls: :class:`~collections.abc.Callable`\\[..., :class:`Loop`]\n        A callable (such as a :class:`Loop` subclass) returning an instance of a :class:`Loop`.\n        If provided, the other parameters described below do not apply.\n        Instead, this decorator will accept the same keyword arguments as the passed callable does.\n\n        .. versionadded:: 2.6\n\n    seconds: :class:`float`\n        The number of seconds between every iteration.\n    minutes: :class:`float`\n        The number of minutes between every iteration.\n    hours: :class:`float`\n        The number of hours between every iteration.\n    time: :class:`datetime.time` | :class:`~collections.abc.Sequence`\\[:class:`datetime.time`]\n        The exact times to run this loop at. Either a non-empty list or a single\n        value of :class:`datetime.time` should be passed. Timezones are supported.\n        If no timezone is given for the times, it is assumed to represent UTC time.\n\n        This cannot be used in conjunction with the relative time parameters.\n\n        .. note::\n\n            Duplicate times will be ignored, and only run once.\n\n        .. versionadded:: 2.0\n\n    count: :class:`int` | :data:`None`\n        The number of loops to do, :data:`None` if it should be an infinite loop.\n    reconnect: :class:`bool`\n        Whether to handle errors and restart the task using an exponential back-off algorithm\n        similar to the one used in :meth:`disnake.Client.connect`.\n    loop: :class:`asyncio.AbstractEventLoop`\n        The loop to use to register the task, if not given defaults to the current event loop\n        or creates a new one if there is none.\n\n    Raises\n    ------\n    ValueError\n        An invalid value for the ``count`` or ``time`` parameter was given.\n    TypeError\n        The function was not a coroutine, the ``cls`` parameter was not a callable\n        nor a subclass of ``Loop``, an invalid value for the ``time`` parameter was passed,\n        or the ``time`` parameter was passed in conjunction with relative time parameters.\n    \"\"\"\n    if not callable(cls):\n        msg = \"cls argument must be callable\"\n        raise TypeError(msg)\n\n    def decorator(func: LF) -> L_co:\n        if not iscoroutinefunction(func):\n            msg = \"The decorated function must be a coroutine function.\"\n            raise TypeError(msg)\n\n        return cast(\"type[L_co]\", cls)(func, **kwargs)\n\n    return decorator", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 25528}, "tests/ui/test_action_row.py::129": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow"], "enclosing_function": "test_pop", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/ext/commands/test_slash_core.py::33": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_qualified_name", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_abc.py::30": {"resolved_imports": ["disnake/__init__.py", "disnake/abc.py"], "used_names": ["GuildChannel"], "enclosing_function": "test_none", "extracted_code": "# Source: disnake/abc.py\nclass GuildChannel(ABC):\n    \"\"\"An ABC that details the common operations on a Discord guild channel.\n\n    The following classes implement this ABC:\n\n    - :class:`.TextChannel`\n    - :class:`.VoiceChannel`\n    - :class:`.CategoryChannel`\n    - :class:`.StageChannel`\n    - :class:`.ForumChannel`\n    - :class:`.MediaChannel`\n\n    This ABC must also implement :class:`.abc.Snowflake`.\n\n    Attributes\n    ----------\n    name: :class:`str`\n        The channel name.\n    guild: :class:`.Guild`\n        The guild the channel belongs to.\n    position: :class:`int`\n        The position in the channel list. This is a number that starts at 0.\n        e.g. the top channel is position 0.\n    \"\"\"\n\n    __slots__ = ()\n\n    id: int\n    name: str\n    guild: Guild\n    type: ChannelType\n    position: int\n    category_id: int | None\n    _flags: int\n    _state: ConnectionState\n    _overwrites: list[_Overwrites]\n\n    if TYPE_CHECKING:\n\n        def __init__(\n            self, *, state: ConnectionState, guild: Guild, data: Mapping[str, Any]\n        ) -> None: ...\n\n    def __str__(self) -> str:\n        return self.name\n\n    @property\n    def _sorting_bucket(self) -> int:\n        raise NotImplementedError\n\n    def _update(self, guild: Guild, data: dict[str, Any]) -> None:\n        raise NotImplementedError\n\n    async def _move(\n        self,\n        position: int,\n        parent_id: int | None = None,\n        lock_permissions: bool = False,\n        *,\n        reason: str | None,\n    ) -> None:\n        if position < 0:\n            msg = \"Channel position cannot be less than 0.\"\n            raise ValueError(msg)\n\n        http = self._state.http\n        bucket = self._sorting_bucket\n        channels = [c for c in self.guild.channels if c._sorting_bucket == bucket]\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        channels.sort(key=lambda c: c.position)\n\n        try:\n            # remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # not there somehow lol\n            return\n        else:\n            index = next(\n                (i for i, c in enumerate(channels) if c.position >= position), len(channels)\n            )\n            # add ourselves at our designated position\n            channels.insert(index, self)\n\n        payload: list[ChannelPositionUpdatePayload] = []\n        for index, c in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": c.id, \"position\": index}\n            if parent_id is not MISSING and c.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def _edit(\n        self,\n        *,\n        name: str = MISSING,\n        topic: str | None = MISSING,\n        position: int = MISSING,\n        nsfw: bool = MISSING,\n        sync_permissions: bool = MISSING,\n        category: Snowflake | None = MISSING,\n        slowmode_delay: int | None = MISSING,\n        default_thread_slowmode_delay: int | None = MISSING,\n        default_auto_archive_duration: AnyThreadArchiveDuration | None = MISSING,\n        type: ChannelType = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        bitrate: int = MISSING,\n        user_limit: int = MISSING,\n        rtc_region: str | VoiceRegion | None = MISSING,\n        video_quality_mode: VideoQualityMode = MISSING,\n        flags: ChannelFlags = MISSING,\n        available_tags: Sequence[ForumTag] = MISSING,\n        default_reaction: str | Emoji | PartialEmoji | None = MISSING,\n        default_sort_order: ThreadSortOrder | None = MISSING,\n        default_layout: ThreadLayout = MISSING,\n        reason: str | None = None,\n    ) -> ChannelPayload | None:\n        parent_id: int | None\n        if category is not MISSING:\n            # if category is given, it's either `None` (no parent) or a category channel\n            parent_id = category.id if category else None\n        else:\n            # if it's not given, don't change the category\n            parent_id = MISSING\n\n        rtc_region_payload: str | None\n        if rtc_region is not MISSING:\n            rtc_region_payload = str(rtc_region) if rtc_region is not None else None\n        else:\n            rtc_region_payload = MISSING\n\n        video_quality_mode_payload: int | None\n        if video_quality_mode is not MISSING:\n            video_quality_mode_payload = int(video_quality_mode)\n        else:\n            video_quality_mode_payload = MISSING\n\n        default_auto_archive_duration_payload: int | None\n        if default_auto_archive_duration is not MISSING:\n            default_auto_archive_duration_payload = (\n                int(default_auto_archive_duration)\n                if default_auto_archive_duration is not None\n                else default_auto_archive_duration\n            )\n        else:\n            default_auto_archive_duration_payload = MISSING\n\n        lock_permissions: bool = bool(sync_permissions)\n\n        overwrites_payload: list[PermissionOverwritePayload] = MISSING\n\n        if position is not MISSING:\n            await self._move(\n                position, parent_id=parent_id, lock_permissions=lock_permissions, reason=reason\n            )\n            parent_id = MISSING  # no need to change it again in the edit request below\n        elif lock_permissions:\n            if parent_id is not MISSING:\n                p_id = parent_id\n            else:\n                p_id = self.category_id\n\n            if p_id is not None and (parent := self.guild.get_channel(p_id)):\n                overwrites_payload = [c._asdict() for c in parent._overwrites]\n\n        if overwrites not in (MISSING, None):\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": _Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER,\n                }\n                overwrites_payload.append(payload)\n\n        type_payload: int\n        if type is not MISSING:\n            if not isinstance(type, ChannelType):\n                msg = \"type field must be of type ChannelType\"\n                raise TypeError(msg)\n            type_payload = type.value\n        else:\n            type_payload = MISSING\n\n        flags_payload: int\n        if flags is not MISSING:\n            if not isinstance(flags, ChannelFlags):\n                msg = \"flags field must be of type ChannelFlags\"\n                raise TypeError(msg)\n            flags_payload = flags.value\n        else:\n            flags_payload = MISSING\n\n        available_tags_payload: list[PartialForumTagPayload] = MISSING\n        if available_tags is not MISSING:\n            available_tags_payload = [tag.to_dict() for tag in available_tags]\n\n        default_reaction_emoji_payload: DefaultReactionPayload | None = MISSING\n        if default_reaction is not MISSING:\n            if default_reaction is not None:\n                emoji_name, emoji_id = PartialEmoji._emoji_to_name_id(default_reaction)\n                default_reaction_emoji_payload = {\n                    \"emoji_name\": emoji_name,\n                    \"emoji_id\": emoji_id,\n                }\n            else:\n                default_reaction_emoji_payload = None\n\n        default_sort_order_payload: int | None = MISSING\n        if default_sort_order is not MISSING:\n            default_sort_order_payload = (\n                try_enum_to_int(default_sort_order) if default_sort_order is not None else None\n            )\n\n        default_layout_payload: int = MISSING\n        if default_layout is not MISSING:\n            default_layout_payload = try_enum_to_int(default_layout)\n\n        options: dict[str, Any] = {\n            \"name\": name,\n            \"parent_id\": parent_id,\n            \"topic\": topic,\n            \"bitrate\": bitrate,\n            \"nsfw\": nsfw,\n            \"user_limit\": user_limit,\n            # note: not passing `position` as it already got updated before, if passed\n            \"permission_overwrites\": overwrites_payload,\n            \"rate_limit_per_user\": slowmode_delay,\n            \"default_thread_rate_limit_per_user\": default_thread_slowmode_delay,\n            \"type\": type_payload,\n            \"rtc_region\": rtc_region_payload,\n            \"video_quality_mode\": video_quality_mode_payload,\n            \"default_auto_archive_duration\": default_auto_archive_duration_payload,\n            \"flags\": flags_payload,\n            \"available_tags\": available_tags_payload,\n            \"default_reaction_emoji\": default_reaction_emoji_payload,\n            \"default_sort_order\": default_sort_order_payload,\n            \"default_forum_layout\": default_layout_payload,\n        }\n        options = {k: v for k, v in options.items() if v is not MISSING}\n\n        if options:\n            return await self._state.http.edit_channel(self.id, reason=reason, **options)\n        return None\n\n    def _fill_overwrites(self, data: GuildChannelPayload) -> None:\n        self._overwrites = []\n        everyone_index = 0\n        everyone_id = self.guild.id\n\n        for index, overridden in enumerate(data.get(\"permission_overwrites\", [])):\n            overwrite = _Overwrites(overridden)\n            self._overwrites.append(overwrite)\n\n            if overwrite.type == _Overwrites.MEMBER:\n                continue\n\n            if overwrite.id == everyone_id:\n                # the @everyone role is not guaranteed to be the first one\n                # in the list of permission overwrites, however the permission\n                # resolution code kind of requires that it is the first one in\n                # the list since it is special. So we need the index so we can\n                # swap it to be the first one.\n                everyone_index = index\n\n        # do the swap\n        tmp = self._overwrites\n        if tmp:\n            tmp[everyone_index], tmp[0] = tmp[0], tmp[everyone_index]\n\n    @property\n    def changed_roles(self) -> list[Role]:\n        r\"\"\":class:`list`\\[:class:`.Role`]: Returns a list of roles that have been overridden from\n        their default values in the :attr:`.Guild.roles` attribute.\n        \"\"\"\n        ret: list[Role] = []\n        g = self.guild\n        for overwrite in filter(lambda o: o.is_role(), self._overwrites):\n            role = g.get_role(overwrite.id)\n            if role is None:\n                continue\n\n            role = copy.copy(role)\n            role.permissions.handle_overwrite(overwrite.allow, overwrite.deny)\n            ret.append(role)\n        return ret\n\n    @property\n    def mention(self) -> str:\n        \"\"\":class:`str`: The string that allows you to mention the channel.\"\"\"\n        return f\"<#{self.id}>\"\n\n    @property\n    def created_at(self) -> datetime:\n        \"\"\":class:`datetime.datetime`: Returns the channel's creation time in UTC.\"\"\"\n        return utils.snowflake_time(self.id)\n\n    def overwrites_for(self, obj: Role | User) -> PermissionOverwrite:\n        \"\"\"Returns the channel-specific overwrites for a member or a role.\n\n        Parameters\n        ----------\n        obj: :class:`.Role` | :class:`.abc.User`\n            The role or user denoting\n            whose overwrite to get.\n\n        Returns\n        -------\n        :class:`~disnake.PermissionOverwrite`\n            The permission overwrites for this object.\n        \"\"\"\n        predicate: Callable[[_Overwrites], bool]\n        if isinstance(obj, User):\n            predicate = lambda p: p.is_member()\n        elif isinstance(obj, Role):\n            predicate = lambda p: p.is_role()\n        else:\n            predicate = lambda p: True\n\n        for overwrite in filter(predicate, self._overwrites):\n            if overwrite.id == obj.id:\n                allow = Permissions(overwrite.allow)\n                deny = Permissions(overwrite.deny)\n                return PermissionOverwrite.from_pair(allow, deny)\n\n        return PermissionOverwrite()\n\n    @property\n    def overwrites(self) -> dict[Role | Member, PermissionOverwrite]:\n        r\"\"\"Returns all of the channel's overwrites.\n\n        This is returned as a dictionary where the key contains the target which\n        can be either a :class:`~disnake.Role` or a :class:`~disnake.Member` and the value is the\n        overwrite as a :class:`~disnake.PermissionOverwrite`.\n\n        Returns\n        -------\n        :class:`dict`\\[:class:`~disnake.Role` | :class:`~disnake.Member`, :class:`~disnake.PermissionOverwrite`]\n            The channel's permission overwrites.\n        \"\"\"\n        ret = {}\n        for ow in self._overwrites:\n            allow = Permissions(ow.allow)\n            deny = Permissions(ow.deny)\n            overwrite = PermissionOverwrite.from_pair(allow, deny)\n            target = None\n\n            if ow.is_role():\n                target = self.guild.get_role(ow.id)\n            elif ow.is_member():\n                target = self.guild.get_member(ow.id)\n\n            # TODO: There is potential data loss here in the non-chunked\n            # case, i.e. target is None because get_member returned nothing.\n            # This can be fixed with a slight breaking change to the return type,\n            # i.e. adding disnake.Object to the list of it\n            # However, for now this is an acceptable compromise.\n            if target is not None:\n                ret[target] = overwrite\n        return ret\n\n    @property\n    def category(self) -> CategoryChannel | None:\n        \"\"\":class:`~disnake.CategoryChannel` | :data:`None`: The category this channel belongs to.\n\n        If there is no category then this is :data:`None`.\n        \"\"\"\n        if isinstance(self.guild, Object):\n            return None\n        return self.guild.get_channel(self.category_id)  # pyright: ignore[reportArgumentType, reportReturnType]\n\n    @property\n    def permissions_synced(self) -> bool:\n        \"\"\":class:`bool`: Whether or not the permissions for this channel are synced with the\n        category it belongs to.\n\n        If there is no category then this is ``False``.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self.category_id is None or isinstance(self.guild, Object):\n            return False\n\n        category = self.guild.get_channel(self.category_id)\n        return bool(category and category.overwrites == self.overwrites)\n\n    @property\n    def flags(self) -> ChannelFlags:\n        \"\"\":class:`.ChannelFlags`: The channel flags for this channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return ChannelFlags._from_value(self._flags)\n\n    @property\n    def jump_url(self) -> str:\n        \"\"\"A URL that can be used to jump to this channel.\n\n        .. versionadded:: 2.4\n\n        .. note::\n\n            This exists for all guild channels but may not be usable by the client for all guild channel types.\n        \"\"\"\n        return f\"https://discord.com/channels/{self.guild.id}/{self.id}\"\n\n    def _apply_implict_permissions(self, base: Permissions) -> None:\n        # if you can't send a message in a channel then you can't have certain\n        # permissions as well\n        if not base.send_messages:\n            base.send_tts_messages = False\n            base.send_voice_messages = False\n            base.send_polls = False\n            base.mention_everyone = False\n            base.embed_links = False\n            base.attach_files = False\n\n        # if you can't view a channel then you have no permissions there\n        if not base.view_channel:\n            denied = Permissions.all_channel()\n            base.value &= ~denied.value\n\n    def permissions_for(\n        self,\n        obj: Member | Role,\n        /,\n        *,\n        ignore_timeout: bool = MISSING,\n    ) -> Permissions:\n        \"\"\"Handles permission resolution for the :class:`~disnake.Member`\n        or :class:`~disnake.Role`.\n\n        This function takes into consideration the following cases:\n\n        - Guild owner\n        - Guild roles\n        - Channel overrides\n        - Member overrides\n        - Timeouts\n\n        If a :class:`~disnake.Role` is passed, then it checks the permissions\n        someone with that role would have, which is essentially:\n\n        - The default role permissions\n        - The permissions of the role used as a parameter\n        - The default role permission overwrites\n        - The permission overwrites of the role used as a parameter\n\n        .. note::\n            If the channel originated from an :class:`.Interaction` and\n            the :attr:`.guild` attribute is unavailable, such as with\n            user-installed applications in guilds, this method will not work\n            due to an API limitation.\n            Consider using :attr:`.Interaction.permissions` or :attr:`~.Interaction.app_permissions` instead.\n\n        .. versionchanged:: 2.0\n            The object passed in can now be a role object.\n\n        Parameters\n        ----------\n        obj: :class:`~disnake.Member` | :class:`~disnake.Role`\n            The object to resolve permissions for. This could be either\n            a member or a role. If it's a role then member overwrites\n            are not computed.\n        ignore_timeout: :class:`bool`\n            Whether or not to ignore the user's timeout.\n            Defaults to ``False``.\n\n            .. versionadded:: 2.4\n\n            .. note::\n\n                This only applies to :class:`~disnake.Member` objects.\n\n            .. versionchanged:: 2.6\n\n                The default was changed to ``False``.\n\n        Raises\n        ------\n        TypeError\n            ``ignore_timeout`` is only supported for :class:`~disnake.Member` objects.\n\n        Returns\n        -------\n        :class:`~disnake.Permissions`\n            The resolved permissions for the member or role.\n        \"\"\"\n        # The current cases can be explained as:\n        # Guild owner get all permissions -- no questions asked. Otherwise...\n        # The @everyone role gets the first application.\n        # After that, the applied roles that the user has in the channel\n        # (or otherwise) are then OR'd together.\n        # After the role permissions are resolved, the member permissions\n        # have to take into effect.\n        # After all that is done.. you have to do the following:\n\n        # The operation first takes into consideration the denied\n        # and then the allowed.\n\n        # Timeouted users have only view_channel and read_message_history\n        # if they already have them.\n        if ignore_timeout is not MISSING and isinstance(obj, Role):\n            msg = \"ignore_timeout is only supported for disnake.Member objects\"\n            raise TypeError(msg)\n\n        if ignore_timeout is MISSING:\n            ignore_timeout = False\n\n        if self.guild.owner_id == obj.id:\n            return Permissions.all()\n\n        default = self.guild.default_role\n        base = Permissions(default.permissions.value)\n\n        # Handle the role case first\n        if isinstance(obj, Role):\n            base.value |= obj._permissions\n\n            if base.administrator:\n                return Permissions.all()\n\n            # Apply @everyone allow/deny first since it's special\n            try:\n                maybe_everyone = self._overwrites[0]\n                if maybe_everyone.id == self.guild.id:\n                    base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n            except IndexError:\n                pass\n\n            if obj.is_default():\n                return base\n\n            overwrite = utils.get(self._overwrites, type=_Overwrites.ROLE, id=obj.id)\n            if overwrite is not None:\n                base.handle_overwrite(overwrite.allow, overwrite.deny)\n\n            return base\n\n        roles = obj._roles\n        get_role = self.guild.get_role\n\n        # Apply guild roles that the member has.\n        for role_id in roles:\n            role = get_role(role_id)\n            if role is not None:\n                base.value |= role._permissions\n\n        # Guild-wide Administrator -> True for everything\n        # Bypass all channel-specific overrides\n        if base.administrator:\n            return Permissions.all()\n\n        # Apply @everyone allow/deny first since it's special\n        try:\n            maybe_everyone = self._overwrites[0]\n            if maybe_everyone.id == self.guild.id:\n                base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n                remaining_overwrites = self._overwrites[1:]\n            else:\n                remaining_overwrites = self._overwrites\n        except IndexError:\n            remaining_overwrites = self._overwrites\n\n        denies = 0\n        allows = 0\n\n        # Apply channel specific role permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_role() and roles.has(overwrite.id):\n                denies |= overwrite.deny\n                allows |= overwrite.allow\n\n        base.handle_overwrite(allow=allows, deny=denies)\n\n        # Apply member specific permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_member() and overwrite.id == obj.id:\n                base.handle_overwrite(allow=overwrite.allow, deny=overwrite.deny)\n                break\n\n        # if you have a timeout then you can't have any permissions\n        # except read messages and read message history\n        if not ignore_timeout and obj.current_timeout:\n            allowed = Permissions(view_channel=True, read_message_history=True)\n            base.value &= allowed.value\n\n        return base\n\n    async def delete(self, *, reason: str | None = None) -> None:\n        \"\"\"|coro|\n\n        Deletes the channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to do this.\n\n        Parameters\n        ----------\n        reason: :class:`str` | :data:`None`\n            The reason for deleting this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to delete the channel.\n        NotFound\n            The channel was not found or was already deleted.\n        HTTPException\n            Deleting the channel failed.\n        \"\"\"\n        await self._state.http.delete_channel(self.id, reason=reason)\n\n    @overload\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        overwrite: PermissionOverwrite | None = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_overload_with_permissions\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        reason: str | None = ...,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    async def set_permissions(\n        self,\n        target,\n        *,\n        overwrite: PermissionOverwrite | None = MISSING,\n        reason: str | None = None,\n        **permissions,\n    ) -> None:\n        \"\"\"|coro|\n\n        Sets the channel specific permission overwrites for a target in the\n        channel.\n\n        The ``target`` parameter should either be a :class:`.Member` or a\n        :class:`.Role` that belongs to guild.\n\n        The ``overwrite`` parameter, if given, must either be :data:`None` or\n        :class:`.PermissionOverwrite`. For convenience, you can pass in\n        keyword arguments denoting :class:`.Permissions` attributes. If this is\n        done, then you cannot mix the keyword arguments with the ``overwrite``\n        parameter.\n\n        If the ``overwrite`` parameter is :data:`None`, then the permission\n        overwrites are deleted.\n\n        You must have :attr:`.Permissions.manage_roles` permission to do this.\n\n        .. note::\n\n            This method *replaces* the old overwrites with the ones given.\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` instead of ``InvalidArgument``.\n\n        Examples\n        --------\n        Setting allow and deny: ::\n\n            await message.channel.set_permissions(message.author, view_channel=True,\n                                                                  send_messages=False)\n\n        Deleting overwrites ::\n\n            await channel.set_permissions(member, overwrite=None)\n\n        Using :class:`.PermissionOverwrite` ::\n\n            overwrite = disnake.PermissionOverwrite()\n            overwrite.send_messages = False\n            overwrite.view_channel = True\n            await channel.set_permissions(member, overwrite=overwrite)\n\n        Parameters\n        ----------\n        target: :class:`.Member` | :class:`.Role`\n            The member or role to overwrite permissions for.\n        overwrite: :class:`.PermissionOverwrite` | :data:`None`\n            The permissions to allow and deny to the target, or :data:`None` to\n            delete the overwrite.\n        **permissions\n            A keyword argument list of permissions to set for ease of use.\n            Cannot be mixed with ``overwrite``.\n        reason: :class:`str` | :data:`None`\n            The reason for doing this action. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to edit channel specific permissions.\n        HTTPException\n            Editing channel specific permissions failed.\n        NotFound\n            The role or member being edited is not part of the guild.\n        TypeError\n            ``overwrite`` is invalid,\n            the target type was not :class:`.Role` or :class:`.Member`,\n            both keyword arguments and ``overwrite`` were provided,\n            or invalid permissions were provided as keyword arguments.\n        \"\"\"\n        http = self._state.http\n\n        if isinstance(target, User):\n            perm_type = _Overwrites.MEMBER\n        elif isinstance(target, Role):\n            perm_type = _Overwrites.ROLE\n        else:\n            msg = \"target parameter must be either Member or Role\"\n            raise TypeError(msg)\n\n        if overwrite is MISSING:\n            if len(permissions) == 0:\n                msg = \"No overwrite provided.\"\n                raise TypeError(msg)\n            try:\n                overwrite = PermissionOverwrite(**permissions)\n            except (ValueError, TypeError) as e:\n                msg = \"Invalid permissions given to keyword arguments.\"\n                raise TypeError(msg) from e\n        else:\n            if len(permissions) > 0:\n                msg = \"Cannot mix overwrite and keyword arguments.\"\n                raise TypeError(msg)\n\n        # TODO: wait for event\n\n        if overwrite is None:\n            await http.delete_channel_permissions(self.id, target.id, reason=reason)\n        elif isinstance(overwrite, PermissionOverwrite):\n            (allow, deny) = overwrite.pair()\n            await http.edit_channel_permissions(\n                self.id, target.id, allow.value, deny.value, perm_type, reason=reason\n            )\n        else:\n            msg = \"Invalid overwrite type provided.\"\n            raise TypeError(msg)\n\n    async def _clone_impl(\n        self,\n        base_attrs: dict[str, Any],\n        *,\n        name: str | None = None,\n        category: Snowflake | None = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        reason: str | None = None,\n    ) -> Self:\n        # if the overwrites are MISSING, defaults to the\n        # original permissions of the channel\n        overwrites_payload: list[PermissionOverwritePayload]\n        if overwrites is not MISSING:\n            if not isinstance(overwrites, dict):\n                msg = \"overwrites parameter expects a dict.\"\n                raise TypeError(msg)\n\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": (_Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER),\n                }\n                overwrites_payload.append(payload)\n        else:\n            overwrites_payload = [x._asdict() for x in self._overwrites]\n        base_attrs[\"permission_overwrites\"] = overwrites_payload\n        if category is not MISSING:\n            base_attrs[\"parent_id\"] = category.id if category else None\n        else:\n            # if no category was given don't change the category\n            base_attrs[\"parent_id\"] = self.category_id\n        base_attrs[\"name\"] = name or self.name\n        channel_type = base_attrs.get(\"type\") or self.type.value\n        guild_id = self.guild.id\n        cls = self.__class__\n        data = await self._state.http.create_channel(\n            guild_id, channel_type, reason=reason, **base_attrs\n        )\n        obj = cls(state=self._state, guild=self.guild, data=data)\n\n        # temporarily add it to the cache\n        self.guild._channels[obj.id] = obj  # pyright: ignore[reportArgumentType]\n        return obj\n\n    async def clone(self, *, name: str | None = None, reason: str | None = None) -> Self:\n        \"\"\"|coro|\n\n        Clones this channel. This creates a channel with the same properties\n        as this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. versionadded:: 1.1\n\n        Parameters\n        ----------\n        name: :class:`str` | :data:`None`\n            The name of the new channel. If not provided, defaults to this channel name.\n        reason: :class:`str` | :data:`None`\n            The reason for cloning this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have the proper permissions to create this channel.\n        HTTPException\n            Creating the channel failed.\n\n        Returns\n        -------\n        :class:`.abc.GuildChannel`\n            The channel that was created.\n        \"\"\"\n        raise NotImplementedError\n\n    @overload\n    async def move(\n        self,\n        *,\n        beginning: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        end: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        before: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        after: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    async def move(self, **kwargs: Any) -> None:\n        \"\"\"|coro|\n\n        A rich interface to help move a channel relative to other channels.\n\n        If exact position movement is required, ``edit`` should be used instead.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. note::\n\n            Voice channels will always be sorted below text channels.\n            This is a Discord limitation.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` or :exc:`ValueError` instead of ``InvalidArgument``.\n\n        Parameters\n        ----------\n        beginning: :class:`bool`\n            Whether to move the channel to the beginning of the\n            channel list (or category if given).\n            This is mutually exclusive with ``end``, ``before``, and ``after``.\n        end: :class:`bool`\n            Whether to move the channel to the end of the\n            channel list (or category if given).\n            This is mutually exclusive with ``beginning``, ``before``, and ``after``.\n        before: :class:`.abc.Snowflake`\n            The channel that should be before our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``after``.\n        after: :class:`.abc.Snowflake`\n            The channel that should be after our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``before``.\n        offset: :class:`int`\n            The number of channels to offset the move by. For example,\n            an offset of ``2`` with ``beginning=True`` would move\n            it 2 after the beginning. A positive number moves it below\n            while a negative number moves it above. Note that this\n            number is relative and computed after the ``beginning``,\n            ``end``, ``before``, and ``after`` parameters.\n        category: :class:`.abc.Snowflake` | :data:`None`\n            The category to move this channel under.\n            If :data:`None` is given then it moves it out of the category.\n            This parameter is ignored if moving a category channel.\n        sync_permissions: :class:`bool`\n            Whether to sync the permissions with the category (if given).\n        reason: :class:`str` | :data:`None`\n            The reason for moving this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to move the channel.\n        HTTPException\n            Moving the channel failed.\n        TypeError\n            A bad mix of arguments were passed.\n        ValueError\n            An invalid position was given.\n        \"\"\"\n        if not kwargs:\n            return\n\n        beginning, end = kwargs.get(\"beginning\"), kwargs.get(\"end\")\n        before, after = kwargs.get(\"before\"), kwargs.get(\"after\")\n        offset = kwargs.get(\"offset\", 0)\n        if sum(bool(a) for a in (beginning, end, before, after)) > 1:\n            msg = \"Only one of [before, after, end, beginning] can be used.\"\n            raise TypeError(msg)\n\n        bucket = self._sorting_bucket\n        parent_id = kwargs.get(\"category\", MISSING)\n        if parent_id not in (MISSING, None):\n            parent_id = parent_id.id\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == parent_id\n            ]\n        else:\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == self.category_id\n            ]\n\n        channels.sort(key=lambda c: (c.position, c.id))\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        try:\n            # Try to remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # If we're not there then it's probably due to not being in the category\n            pass\n\n        index = None\n        if beginning:\n            index = 0\n        elif end:\n            index = len(channels)\n        elif before:\n            index = next((i for i, c in enumerate(channels) if c.id == before.id), None)\n        elif after:\n            index = next((i + 1 for i, c in enumerate(channels) if c.id == after.id), None)\n\n        if index is None:\n            msg = \"Could not resolve appropriate move position\"\n            raise ValueError(msg)\n\n        channels.insert(max((index + offset), 0), self)\n        payload: list[ChannelPositionUpdatePayload] = []\n        lock_permissions = kwargs.get(\"sync_permissions\", False)\n        reason = kwargs.get(\"reason\")\n        for index, channel in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": channel.id, \"position\": index}\n            if parent_id is not MISSING and channel.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await self._state.http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def create_invite(\n        self,\n        *,\n        reason: str | None = None,\n        max_age: int = 0,\n        max_uses: int = 0,\n        temporary: bool = False,\n        unique: bool = True,\n        target_type: InviteTarget | None = None,\n        target_user: User | None = None,\n        target_application: Snowflake | PartyType | None = None,\n        guild_scheduled_event: GuildScheduledEvent | None = None,\n    ) -> Invite:\n        \"\"\"|coro|\n\n        Creates an instant invite from a text or voice channel.\n\n        You must have :attr:`.Permissions.create_instant_invite` permission to\n        do this.\n\n        Parameters\n        ----------\n        max_age: :class:`int`\n            How long the invite should last in seconds. If set to ``0``, then the invite\n            doesn't expire. Defaults to ``0``.\n        max_uses: :class:`int`\n            How many uses the invite could be used for. If it's 0 then there\n            are unlimited uses. Defaults to ``0``.\n        temporary: :class:`bool`\n            Whether the invite grants temporary membership\n            (i.e. they get kicked after they disconnect). Defaults to ``False``.\n        unique: :class:`bool`\n            Whether a unique invite URL should be created. Defaults to ``True``.\n            If this is set to ``False`` then it will return a previously created\n            invite.\n        target_type: :class:`.InviteTarget` | :data:`None`\n            The type of target for the voice channel invite, if any.\n\n            .. versionadded:: 2.0\n\n        target_user: :class:`User` | :data:`None`\n            The user whose stream to display for this invite, required if ``target_type`` is :attr:`.InviteTarget.stream`.\n            The user must be streaming in the channel.\n\n            .. versionadded:: 2.0\n\n        target_application: :class:`.Snowflake` | :data:`None`\n            The ID of the embedded application for the invite, required if ``target_type`` is :attr:`.InviteTarget.embedded_application`.\n\n            .. versionadded:: 2.0\n\n            .. versionchanged:: 2.9\n                ``PartyType`` is deprecated, and :class:`.Snowflake` should be used instead.\n\n        guild_scheduled_event: :class:`.GuildScheduledEvent` | :data:`None`\n            The guild scheduled event to include with the invite.\n\n            .. versionadded:: 2.3\n\n        reason: :class:`str` | :data:`None`\n            The reason for creating this invite. Shows up on the audit log.\n\n        Raises\n        ------\n        HTTPException\n            Invite creation failed.\n        NotFound\n            The channel that was passed is a category or an invalid channel.\n\n        Returns\n        -------\n        :class:`.Invite`\n            The newly created invite.\n        \"\"\"\n        if isinstance(target_application, PartyType):\n            utils.warn_deprecated(\n                \"PartyType is deprecated and will be removed in future version\",\n                stacklevel=2,\n            )\n            target_application = Object(target_application.value)\n        data = await self._state.http.create_invite(\n            self.id,\n            reason=reason,\n            max_age=max_age,\n            max_uses=max_uses,\n            temporary=temporary,\n            unique=unique,\n            target_type=try_enum_to_int(target_type),\n            target_user_id=target_user.id if target_user else None,\n            target_application_id=target_application.id if target_application else None,\n        )\n        invite = Invite.from_incomplete(data=data, state=self._state)\n        invite.guild_scheduled_event = guild_scheduled_event\n        return invite\n\n    async def invites(self) -> list[Invite]:\n        r\"\"\"|coro|\n\n        Returns a list of all active instant invites from this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to use this.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to get the information.\n        HTTPException\n            An error occurred while fetching the information.\n\n        Returns\n        -------\n        :class:`list`\\[:class:`.Invite`]\n            The list of invites that are currently active.\n        \"\"\"\n        state = self._state\n        data = await state.http.invites_from_channel(self.id)\n        guild = self.guild\n        return [Invite(state=state, data=invite, channel=self, guild=guild) for invite in data]", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 43721}, "tests/interactions/test_base.py::214": {"resolved_imports": ["disnake/__init__.py", "disnake/state.py"], "used_names": ["ConnectionState", "disnake", "pytest"], "enclosing_function": "test_channel", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\n\n\n# Source: disnake/state.py\nclass ConnectionState:\n    if TYPE_CHECKING:\n        _get_websocket: Callable[..., DiscordWebSocket]\n        _get_client: Callable[..., Client]\n        _parsers: dict[str, Callable[[dict[str, Any]], None]]\n\n    def __init__(\n        self,\n        *,\n        dispatch: Callable[Concatenate[str, ...], Any],\n        handlers: dict[str, Callable[..., Any]],\n        hooks: dict[str, Callable[..., Any]],\n        http: HTTPClient,\n        loop: asyncio.AbstractEventLoop,\n        max_messages: int | None = 1000,\n        application_id: int | None = None,\n        heartbeat_timeout: float = 60.0,\n        guild_ready_timeout: float = 2.0,\n        allowed_mentions: AllowedMentions | None = None,\n        activity: BaseActivity | None = None,\n        status: str | Status | None = None,\n        intents: Intents | None = None,\n        chunk_guilds_at_startup: bool | None = None,\n        member_cache_flags: MemberCacheFlags | None = None,\n    ) -> None:\n        self.loop: asyncio.AbstractEventLoop = loop\n        self.http: HTTPClient = http\n        self.max_messages: int | None = max_messages\n        if self.max_messages is not None and self.max_messages <= 0:\n            self.max_messages = 1000\n\n        self.dispatch: Callable[Concatenate[str, ...], Any] = dispatch\n        self.handlers: dict[str, Callable[..., Any]] = handlers\n        self.hooks: dict[str, Callable[..., Any]] = hooks\n        self.shard_count: int | None = None\n        self._ready_task: asyncio.Task | None = None\n        self.application_id: int | None = None if application_id is None else int(application_id)\n        self.heartbeat_timeout: float = heartbeat_timeout\n        self.guild_ready_timeout: float = guild_ready_timeout\n        if self.guild_ready_timeout < 0:\n            msg = \"guild_ready_timeout cannot be negative.\"\n            raise ValueError(msg)\n\n        if allowed_mentions is not None and not isinstance(allowed_mentions, AllowedMentions):\n            msg = \"allowed_mentions parameter must be AllowedMentions.\"\n            raise TypeError(msg)\n\n        self.allowed_mentions: AllowedMentions | None = allowed_mentions\n        self._chunk_requests: dict[int | str, ChunkRequest] = {}\n\n        if activity:\n            if not isinstance(activity, BaseActivity):\n                msg = \"activity parameter must derive from BaseActivity.\"\n                raise TypeError(msg)\n\n            self._activity: ActivityPayload | None = activity.to_dict()\n        else:\n            self._activity: ActivityPayload | None = None\n\n        self._status: str | None = None\n        if status:\n            self._status = \"invisible\" if status is Status.offline else str(status)\n\n        if intents is not None:\n            if not isinstance(intents, Intents):\n                msg = f\"intents parameter must be Intents, not {type(intents)!r}.\"\n                raise TypeError(msg)\n\n            if not intents.guilds:\n                _log.warning(\n                    \"Guilds intent seems to be disabled. This may cause state related issues.\"\n                )\n\n            self._intents: Intents = intents\n        else:\n            self._intents: Intents = Intents.default()\n\n        self._chunk_guilds: bool = (\n            self._intents.members if chunk_guilds_at_startup is None else chunk_guilds_at_startup\n        )\n\n        # Ensure these two are set properly\n        if not self._intents.members and self._chunk_guilds:\n            msg = \"Intents.members must be enabled to chunk guilds at startup.\"\n            raise ValueError(msg)\n\n        if member_cache_flags is None:\n            member_cache_flags = MemberCacheFlags.from_intents(self._intents)\n        else:\n            if not isinstance(member_cache_flags, MemberCacheFlags):\n                msg = (\n                    \"member_cache_flags parameter must be MemberCacheFlags, \"\n                    f\"not {type(member_cache_flags)!r}\"\n                )\n                raise TypeError(msg)\n\n            member_cache_flags._verify_intents(self._intents)\n\n        self.member_cache_flags: MemberCacheFlags = member_cache_flags\n\n        if not self._intents.members or member_cache_flags._empty:\n            self.store_user = self.create_user\n\n        self.parsers = parsers = {}\n        for attr, func in inspect.getmembers(self):\n            if attr.startswith(\"parse_\"):\n                parsers[attr[6:].upper()] = func\n\n        self.clear()\n\n    def clear(\n        self, *, views: bool = True, application_commands: bool = True, modals: bool = True\n    ) -> None:\n        self.user: ClientUser = MISSING\n        # NOTE: without weakrefs, these user objects would otherwise be kept in memory indefinitely.\n        # However, using weakrefs here unfortunately has a few drawbacks:\n        # - the weakref slot + object in user objects likely results in a small increase in memory usage\n        # - accesses on `_users` are slower, e.g. `__getitem__` takes ~1us with weakrefs and ~0.2us without\n        self._users: weakref.WeakValueDictionary[int, User] = weakref.WeakValueDictionary()\n        self._emojis: dict[int, Emoji] = {}\n        self._stickers: dict[int, GuildSticker] = {}\n        self._soundboard_sounds: dict[int, GuildSoundboardSound] = {}\n        self._guilds: dict[int, Guild] = {}\n\n        if application_commands:\n            self._global_application_commands: dict[int, APIApplicationCommand] = {}\n            self._guild_application_commands: dict[int, dict[int, APIApplicationCommand]] = {}\n\n        if views:\n            self._view_store: ViewStore = ViewStore(self)\n\n        if modals:\n            self._modal_store: ModalStore = ModalStore(self)\n\n        self._voice_clients: dict[int, VoiceProtocol] = {}\n\n        # LRU of max size 128\n        self._private_channels: OrderedDict[int, PrivateChannel] = OrderedDict()\n        # extra dict to look up private channels by user id\n        self._private_channels_by_user: dict[int, DMChannel] = {}\n        if self.max_messages is not None:\n            self._messages: deque[Message] | None = deque(maxlen=self.max_messages)\n        else:\n            self._messages: deque[Message] | None = None\n\n    def process_chunk_requests(\n        self, guild_id: int, nonce: str | None, members: list[Member], complete: bool\n    ) -> None:\n        removed = []\n        for key, request in self._chunk_requests.items():\n            if request.guild_id == guild_id and request.nonce == nonce:\n                request.add_members(members)\n                if complete:\n                    request.done()\n                    removed.append(key)\n\n        for key in removed:\n            del self._chunk_requests[key]\n\n    def call_handlers(self, key: str, *args: Any, **kwargs: Any) -> None:\n        try:\n            func = self.handlers[key]\n        except KeyError:\n            pass\n        else:\n            func(*args, **kwargs)\n\n    async def call_hooks(self, key: str, *args: Any, **kwargs: Any) -> None:\n        try:\n            coro = self.hooks[key]\n        except KeyError:\n            pass\n        else:\n            await coro(*args, **kwargs)\n\n    @property\n    def self_id(self) -> int | None:\n        u = self.user\n        return u.id if u else None\n\n    @property\n    def intents(self) -> Intents:\n        ret = Intents.none()\n        ret.value = self._intents.value\n        return ret\n\n    @property\n    def voice_clients(self) -> list[VoiceProtocol]:\n        return list(self._voice_clients.values())\n\n    def _get_voice_client(self, guild_id: int | None) -> VoiceProtocol | None:\n        # the keys of self._voice_clients are ints\n        return self._voice_clients.get(guild_id)  # pyright: ignore[reportArgumentType]\n\n    def _add_voice_client(self, guild_id: int, voice: VoiceProtocol) -> None:\n        self._voice_clients[guild_id] = voice\n\n    def _remove_voice_client(self, guild_id: int) -> None:\n        self._voice_clients.pop(guild_id, None)\n\n    def _update_references(self, ws: DiscordWebSocket) -> None:\n        for vc in self.voice_clients:\n            vc.main_ws = ws  # pyright: ignore[reportAttributeAccessIssue]\n\n    def store_user(self, data: UserPayload) -> User:\n        user_id = int(data[\"id\"])\n        try:\n            return self._users[user_id]\n        except KeyError:\n            user = User(state=self, data=data)\n            if user.discriminator != \"0000\":\n                self._users[user_id] = user\n            return user\n\n    def create_user(self, data: UserPayload) -> User:\n        return User(state=self, data=data)\n\n    def get_user(self, id: int | None) -> User | None:\n        # the keys of self._users are ints\n        return self._users.get(id)  # pyright: ignore[reportArgumentType]\n\n    def store_emoji(self, guild: Guild, data: EmojiPayload) -> Emoji:\n        # the id will be present here\n        assert data[\"id\"] is not None\n        emoji_id = int(data[\"id\"])\n        self._emojis[emoji_id] = emoji = Emoji(guild=guild, state=self, data=data)\n        return emoji\n\n    def store_sticker(self, guild: Guild, data: GuildStickerPayload) -> GuildSticker:\n        sticker_id = int(data[\"id\"])\n        self._stickers[sticker_id] = sticker = GuildSticker(state=self, data=data)\n        return sticker\n\n    def store_soundboard_sound(\n        self, guild: Guild, data: GuildSoundboardSoundPayload\n    ) -> GuildSoundboardSound:\n        sound_id = int(data[\"sound_id\"])\n        self._soundboard_sounds[sound_id] = sound = GuildSoundboardSound(\n            state=self, data=data, guild_id=guild.id\n        )\n        return sound\n\n    def store_view(self, view: View, message_id: int | None = None) -> None:\n        self._view_store.add_view(view, message_id)\n\n    def store_modal(self, user_id: int, modal: Modal) -> None:\n        self._modal_store.add_modal(user_id, modal)\n\n    def prevent_view_updates_for(self, message_id: int) -> View | None:\n        return self._view_store.remove_message_tracking(message_id)\n\n    @property\n    def persistent_views(self) -> Sequence[View]:\n        return self._view_store.persistent_views\n\n    @property\n    def guilds(self) -> list[Guild]:\n        return list(self._guilds.values())\n\n    def _get_guild(self, guild_id: int | None) -> Guild | None:\n        # the keys of self._guilds are ints\n        if guild_id is None:\n            return None\n        return self._guilds.get(guild_id)\n\n    def _add_guild(self, guild: Guild) -> None:\n        self._guilds[guild.id] = guild\n\n    def _remove_guild(self, guild: Guild) -> None:\n        self._guilds.pop(guild.id, None)\n\n        for emoji in guild.emojis:\n            self._emojis.pop(emoji.id, None)\n\n        for sticker in guild.stickers:\n            self._stickers.pop(sticker.id, None)\n\n        for sound in guild.soundboard_sounds:\n            self._soundboard_sounds.pop(sound.id, None)\n\n        del guild\n\n    def _get_global_application_command(\n        self, application_command_id: int\n    ) -> APIApplicationCommand | None:\n        return self._global_application_commands.get(application_command_id)\n\n    def _add_global_application_command(\n        self,\n        application_command: APIApplicationCommand,\n        /,\n    ) -> None:\n        if not application_command.id:\n            msg = \"The provided application command does not have an ID\"\n            raise AssertionError(msg)\n        self._global_application_commands[application_command.id] = application_command\n\n    def _remove_global_application_command(self, application_command_id: int, /) -> None:\n        self._global_application_commands.pop(application_command_id, None)\n\n    def _clear_global_application_commands(self) -> None:\n        self._global_application_commands.clear()\n\n    def _get_guild_application_command(\n        self, guild_id: int, application_command_id: int\n    ) -> APIApplicationCommand | None:\n        granula = self._guild_application_commands.get(guild_id)\n        if granula is not None:\n            return granula.get(application_command_id)\n        return None\n\n    def _add_guild_application_command(\n        self, guild_id: int, application_command: APIApplicationCommand\n    ) -> None:\n        if not application_command.id:\n            msg = \"The provided application command does not have an ID\"\n            raise AssertionError(msg)\n        try:\n            granula = self._guild_application_commands[guild_id]\n            granula[application_command.id] = application_command\n        except KeyError:\n            self._guild_application_commands[guild_id] = {\n                application_command.id: application_command\n            }\n\n    def _remove_guild_application_command(self, guild_id: int, application_command_id: int) -> None:\n        try:\n            granula = self._guild_application_commands[guild_id]\n            granula.pop(application_command_id, None)\n        except KeyError:\n            pass\n\n    def _clear_guild_application_commands(self, guild_id: int) -> None:\n        self._guild_application_commands.pop(guild_id, None)\n\n    def _get_global_command_named(\n        self, name: str, cmd_type: ApplicationCommandType | None = None\n    ) -> APIApplicationCommand | None:\n        for cmd in self._global_application_commands.values():\n            if cmd.name == name and (cmd_type is None or cmd.type is cmd_type):\n                return cmd\n        return None\n\n    def _get_guild_command_named(\n        self, guild_id: int, name: str, cmd_type: ApplicationCommandType | None = None\n    ) -> APIApplicationCommand | None:\n        granula = self._guild_application_commands.get(guild_id, {})\n        for cmd in granula.values():\n            if cmd.name == name and (cmd_type is None or cmd.type is cmd_type):\n                return cmd\n        return None\n\n    @property\n    def emojis(self) -> list[Emoji]:\n        return list(self._emojis.values())\n\n    @property\n    def stickers(self) -> list[GuildSticker]:\n        return list(self._stickers.values())\n\n    @property\n    def soundboard_sounds(self) -> list[GuildSoundboardSound]:\n        return list(self._soundboard_sounds.values())\n\n    def get_emoji(self, emoji_id: int | None) -> Emoji | None:\n        # the keys of self._emojis are ints\n        return self._emojis.get(emoji_id)  # pyright: ignore[reportArgumentType]\n\n    def get_sticker(self, sticker_id: int | None) -> GuildSticker | None:\n        # the keys of self._stickers are ints\n        return self._stickers.get(sticker_id)  # pyright: ignore[reportArgumentType]\n\n    def get_soundboard_sound(self, sound_id: int | None) -> GuildSoundboardSound | None:\n        # the keys of self._soundboard_sounds are ints\n        return self._soundboard_sounds.get(sound_id)  # pyright: ignore[reportArgumentType]\n\n    @property\n    def private_channels(self) -> list[PrivateChannel]:\n        return list(self._private_channels.values())\n\n    def _get_private_channel(self, channel_id: int | None) -> PrivateChannel | None:\n        try:\n            # the keys of self._private_channels are ints\n            value = self._private_channels[channel_id]  # pyright: ignore[reportArgumentType]\n        except KeyError:\n            return None\n        else:\n            self._private_channels.move_to_end(channel_id)  # pyright: ignore[reportArgumentType]\n            return value\n\n    def _get_private_channel_by_user(self, user_id: int | None) -> DMChannel | None:\n        # the keys of self._private_channels are ints\n        return self._private_channels_by_user.get(user_id)  # pyright: ignore[reportArgumentType]\n\n    def _add_private_channel(self, channel: PrivateChannel) -> None:\n        channel_id = channel.id\n        self._private_channels[channel_id] = channel\n\n        if len(self._private_channels) > 128:\n            _, to_remove = self._private_channels.popitem(last=False)\n            if isinstance(to_remove, DMChannel) and to_remove.recipient:\n                self._private_channels_by_user.pop(to_remove.recipient.id, None)\n\n        if isinstance(channel, DMChannel) and channel.recipient:\n            self._private_channels_by_user[channel.recipient.id] = channel\n\n    def add_dm_channel(self, data: DMChannelPayload) -> DMChannel:\n        # self.user is *always* cached when this is called\n        channel = DMChannel(me=self.user, state=self, data=data)\n        self._add_private_channel(channel)\n        return channel\n\n    def _remove_private_channel(self, channel: PrivateChannel) -> None:\n        self._private_channels.pop(channel.id, None)\n        if isinstance(channel, DMChannel):\n            recipient = channel.recipient\n            if recipient is not None:\n                self._private_channels_by_user.pop(recipient.id, None)\n\n    def _get_message(self, msg_id: int | None) -> Message | None:\n        return (\n            utils.find(lambda m: m.id == msg_id, reversed(self._messages))\n            if self._messages\n            else None\n        )\n\n    def _add_guild_from_data(self, data: GuildPayload | UnavailableGuildPayload) -> Guild:\n        guild = Guild(\n            data=data,  # pyright: ignore[reportArgumentType]  # may be unavailable guild\n            state=self,\n        )\n        self._add_guild(guild)\n        return guild\n\n    def _guild_needs_chunking(self, guild: Guild) -> bool:\n        # If presences are enabled then we get back the old guild.large behaviour\n        return (\n            self._chunk_guilds\n            and not guild.chunked\n            and not (self._intents.presences and not guild.large)\n        )\n\n    def _get_guild_channel(\n        self,\n        data: MessagePayload | gateway.TypingStartEvent,\n    ) -> tuple[PartialChannel | Thread, Guild | None]:\n        channel_id = int(data[\"channel_id\"])\n        guild_id = utils._get_as_snowflake(data, \"guild_id\")\n\n        if guild_id is None:\n            # if we're here, this is a DM channel or an ephemeral message in a guild\n            channel = self.get_channel(channel_id)\n            if channel is None:\n                if \"author\" in data:\n                    # MessagePayload\n                    user_id = int(data[\"author\"][\"id\"])\n                else:\n                    # TypingStartEvent\n                    user_id = int(data[\"user_id\"])\n                channel = DMChannel._from_message(self, channel_id, user_id)\n            guild = None\n        else:\n            guild = self._get_guild(guild_id)\n            channel = guild and guild._resolve_channel(channel_id)\n\n        return channel or PartialMessageable(state=self, id=channel_id), guild\n\n    async def chunker(\n        self,\n        guild_id: int,\n        query: str = \"\",\n        limit: int = 0,\n        presences: bool = False,\n        *,\n        nonce: str | None = None,\n    ) -> None:\n        ws = self._get_websocket(guild_id)  # This is ignored upstream\n        await ws.request_chunks(\n            guild_id, query=query, limit=limit, presences=presences, nonce=nonce\n        )\n\n    async def query_members(\n        self,\n        guild: Guild,\n        query: str | None,\n        limit: int,\n        user_ids: list[int] | None,\n        cache: bool,\n        presences: bool,\n    ) -> list[Member]:\n        guild_id = guild.id\n        ws = self._get_websocket(guild_id)\n\n        request = ChunkRequest(guild.id, self.loop, self._get_guild, cache=cache)\n        self._chunk_requests[request.nonce] = request\n\n        try:\n            # start the query operation\n            await ws.request_chunks(\n                guild_id,\n                query=query,\n                limit=limit,\n                user_ids=user_ids,\n                presences=presences,\n                nonce=request.nonce,\n            )\n            return await asyncio.wait_for(request.wait(), timeout=30.0)\n        except asyncio.TimeoutError:\n            _log.warning(\n                \"Timed out waiting for chunks with query %r and limit %d for guild_id %d\",\n                query,\n                limit,\n                guild_id,\n            )\n            raise\n\n    async def _delay_ready(self) -> None:\n        try:\n            states = []\n            while True:\n                # this snippet of code is basically waiting N seconds\n                # until the last GUILD_CREATE was sent\n                try:\n                    guild = await asyncio.wait_for(\n                        self._ready_state.get(), timeout=self.guild_ready_timeout\n                    )\n                except asyncio.TimeoutError:\n                    break\n                else:\n                    if self._guild_needs_chunking(guild):\n                        future = await self.chunk_guild(guild, wait=False)\n                        states.append((guild, future))\n                    else:\n                        if guild.unavailable is False:\n                            self.dispatch(\"guild_available\", guild)\n                        else:\n                            self.dispatch(\"guild_join\", guild)\n\n            for guild, future in states:\n                try:\n                    await asyncio.wait_for(future, timeout=5.0)\n                except asyncio.TimeoutError:\n                    _log.warning(\n                        \"Shard ID %s timed out waiting for chunks for guild_id %s.\",\n                        guild.shard_id,\n                        guild.id,\n                    )\n\n                if guild.unavailable is False:\n                    self.dispatch(\"guild_available\", guild)\n                else:\n                    self.dispatch(\"guild_join\", guild)\n\n            # remove the state\n            try:\n                del self._ready_state\n            except AttributeError:\n                pass  # already been deleted somehow\n\n        except asyncio.CancelledError:\n            pass\n        else:\n            # dispatch the event\n            self.call_handlers(\"ready\")\n            self.dispatch(\"ready\")\n        finally:\n            self._ready_task = None\n\n    def parse_ready(self, data: gateway.ReadyEvent) -> None:\n        if self._ready_task is not None:\n            self._ready_task.cancel()\n\n        self._ready_state: asyncio.Queue[Guild] = asyncio.Queue()\n        self.clear(views=False, application_commands=False, modals=False)\n        self.user = ClientUser(state=self, data=data[\"user\"])\n        # self._users is a list of Users, we're setting a ClientUser\n        self._users[self.user.id] = self.user  # pyright: ignore[reportArgumentType]\n\n        try:\n            application = data[\"application\"]\n        except KeyError:\n            pass\n        else:\n            if self.application_id is None:\n                self.application_id = utils._get_as_snowflake(application, \"id\")\n            self.application_flags = ApplicationFlags._from_value(application[\"flags\"])\n\n        for guild_data in data[\"guilds\"]:\n            self._add_guild_from_data(guild_data)\n\n        self.dispatch(\"connect\")\n        self.call_handlers(\"connect_internal\")\n        self._ready_task = asyncio.create_task(self._delay_ready())\n\n    def parse_resumed(self, data: gateway.ResumedEvent) -> None:\n        self.dispatch(\"resumed\")\n\n    def parse_application_command_permissions_update(\n        self, data: gateway.ApplicationCommandPermissionsUpdateEvent\n    ) -> None:\n        app_command_perms = GuildApplicationCommandPermissions(data=data, state=self)\n        self.dispatch(\"application_command_permissions_update\", app_command_perms)\n\n    def parse_message_create(self, data: gateway.MessageCreateEvent) -> None:\n        channel, _ = self._get_guild_channel(data)\n        # channel would be the correct type here\n        message = Message(channel=channel, data=data, state=self)  # pyright: ignore[reportArgumentType]\n        self.dispatch(\"message\", message)\n        if self._messages is not None:\n            self._messages.append(message)\n\n        if channel:\n            # we ensure that the channel is a type that implements last_message_id\n            if channel.__class__ in (TextChannel, Thread, VoiceChannel, StageChannel):\n                channel.last_message_id = message.id  # pyright: ignore[reportAttributeAccessIssue]\n            # Essentially, messages *don't* count towards message_count, if:\n            # - they're the thread starter message\n            # - or, they're the initial message of a forum channel thread (which uses MessageType.default)\n            # This mirrors the current client and API behavior.\n            if channel.__class__ is Thread and not (\n                message.type is MessageType.thread_starter_message\n                or (\n                    type(channel.parent) in (ForumChannel, MediaChannel)  # pyright: ignore[reportAttributeAccessIssue]\n                    and channel.id == message.id\n                )\n            ):\n                channel.total_message_sent += 1  # pyright: ignore[reportAttributeAccessIssue]\n                channel.message_count += 1  # pyright: ignore[reportAttributeAccessIssue]\n\n    def parse_message_delete(self, data: gateway.MessageDeleteEvent) -> None:\n        raw = RawMessageDeleteEvent(data)\n        found = self._get_message(raw.message_id)\n        raw.cached_message = found\n        self.dispatch(\"raw_message_delete\", raw)\n\n        # the initial message isn't counted, and hence shouldn't be subtracted from the count either\n        if raw.message_id != raw.channel_id:\n            guild = self._get_guild(raw.guild_id)\n            thread = guild and guild.get_thread(raw.channel_id)\n            if thread:\n                thread.message_count = max(0, thread.message_count - 1)\n\n        if self._messages is not None and found is not None:\n            self.dispatch(\"message_delete\", found)\n            self._messages.remove(found)\n\n    def parse_message_delete_bulk(self, data: gateway.MessageDeleteBulkEvent) -> None:\n        raw = RawBulkMessageDeleteEvent(data)\n        if self._messages:\n            found_messages = [\n                message for message in self._messages if message.id in raw.message_ids\n            ]\n        else:\n            found_messages = []\n        raw.cached_messages = found_messages\n        self.dispatch(\"raw_bulk_message_delete\", raw)\n        guild = self._get_guild(raw.guild_id)\n        thread = guild and guild.get_thread(raw.channel_id)\n        if thread:\n            to_subtract = len(raw.message_ids)\n            # the initial message isn't counted, and hence shouldn't be subtracted from the count either\n            if raw.channel_id in raw.message_ids:\n                to_subtract -= 1\n            thread.message_count = max(0, thread.message_count - to_subtract)\n        if found_messages:\n            self.dispatch(\"bulk_message_delete\", found_messages)\n            # self._messages won't be None here\n            assert self._messages is not None\n            for msg in found_messages:\n                self._messages.remove(msg)\n\n    def parse_message_update(self, data: gateway.MessageUpdateEvent) -> None:\n        raw = RawMessageUpdateEvent(data)\n        message = self._get_message(raw.message_id)\n        if message is not None:\n            older_message = copy.copy(message)\n            raw.cached_message = older_message\n            self.dispatch(\"raw_message_edit\", raw)\n            message._update(data)\n            # Coerce the `after` parameter to take the new updated Member\n            # ref: #5999\n            older_message.author = message.author\n            self.dispatch(\"message_edit\", older_message, message)\n        else:\n            self.dispatch(\"raw_message_edit\", raw)\n\n        if \"components\" in data and self._view_store.is_message_tracked(raw.message_id):\n            self._view_store.update_from_message(raw.message_id, data[\"components\"])\n\n    def parse_message_reaction_add(self, data: gateway.MessageReactionAddEvent) -> None:\n        emoji = data[\"emoji\"]\n        emoji_id = utils._get_as_snowflake(emoji, \"id\")\n        emoji = PartialEmoji.with_state(\n            self,\n            id=emoji_id,\n            animated=emoji.get(\"animated\", False),\n            name=emoji[\"name\"],  # pyright: ignore[reportArgumentType]\n        )\n        raw = RawReactionActionEvent(data, emoji, \"REACTION_ADD\")\n\n        member_data = data.get(\"member\")\n        if member_data:\n            guild = self._get_guild(raw.guild_id)\n            if guild is not None:\n                raw.member = Member(data=member_data, guild=guild, state=self)\n            else:\n                raw.member = None\n        else:\n            raw.member = None\n        self.dispatch(\"raw_reaction_add\", raw)\n\n        # rich interface here\n        message = self._get_message(raw.message_id)\n        if message is not None:\n            emoji = self._upgrade_partial_emoji(emoji)\n            reaction = message._add_reaction(data, emoji, raw.user_id)\n            user = raw.member or self._get_reaction_user(message.channel, raw.user_id)\n\n            if user:\n                self.dispatch(\"reaction_add\", reaction, user)\n\n    def parse_message_reaction_remove_all(\n        self, data: gateway.MessageReactionRemoveAllEvent\n    ) -> None:\n        raw = RawReactionClearEvent(data)\n        self.dispatch(\"raw_reaction_clear\", raw)\n\n        message = self._get_message(raw.message_id)\n        if message is not None:\n            old_reactions = message.reactions.copy()\n            message.reactions.clear()\n            self.dispatch(\"reaction_clear\", message, old_reactions)\n\n    def parse_message_reaction_remove(self, data: gateway.MessageReactionRemoveEvent) -> None:\n        emoji = data[\"emoji\"]\n        emoji_id = utils._get_as_snowflake(emoji, \"id\")\n        emoji = PartialEmoji.with_state(\n            self,\n            id=emoji_id,\n            animated=emoji.get(\"animated\", False),\n            # may be `None` in gateway events if custom emoji data isn't available anymore\n            # https://docs.discord.com/developers/resources/emoji#emoji-object-custom-emoji-examples\n            name=emoji[\"name\"],  # pyright: ignore[reportArgumentType]\n        )\n        raw = RawReactionActionEvent(data, emoji, \"REACTION_REMOVE\")\n        self.dispatch(\"raw_reaction_remove\", raw)\n\n        message = self._get_message(raw.message_id)\n        if message is not None:\n            emoji = self._upgrade_partial_emoji(emoji)\n            try:\n                reaction = message._remove_reaction(data, emoji, raw.user_id)\n            except (AttributeError, ValueError):  # eventual consistency lol\n                pass\n            else:\n                user = self._get_reaction_user(message.channel, raw.user_id)\n                if user:\n                    self.dispatch(\"reaction_remove\", reaction, user)\n\n    def parse_message_reaction_remove_emoji(\n        self, data: gateway.MessageReactionRemoveEmojiEvent\n    ) -> None:\n        emoji = data[\"emoji\"]\n        emoji_id = utils._get_as_snowflake(emoji, \"id\")\n        emoji = PartialEmoji.with_state(\n            self,\n            id=emoji_id,\n            animated=emoji.get(\"animated\", False),\n            # may be `None` in gateway events if custom emoji data isn't available anymore\n            # https://docs.discord.com/developers/resources/emoji#emoji-object-custom-emoji-examples\n            name=emoji[\"name\"],  # pyright: ignore[reportArgumentType]\n        )\n        raw = RawReactionClearEmojiEvent(data, emoji)\n        self.dispatch(\"raw_reaction_clear_emoji\", raw)\n\n        message = self._get_message(raw.message_id)\n        if message is not None:\n            try:\n                reaction = message._clear_emoji(emoji)\n            except (AttributeError, ValueError):  # eventual consistency lol\n                pass\n            else:\n                if reaction:\n                    self.dispatch(\"reaction_clear_emoji\", reaction)\n\n    def _handle_poll_event(\n        self, raw: RawPollVoteActionEvent, event_type: Literal[\"add\", \"remove\"]\n    ) -> None:\n        guild = self._get_guild(raw.guild_id)\n        answer = None\n        if guild is not None:\n            member = guild.get_member(raw.user_id)\n            message = self._get_message(raw.message_id)\n            if message is not None and message.poll is not None:\n                answer = message.poll.get_answer(raw.answer_id)\n\n            if member is not None:\n                raw.cached_member = member\n\n        if answer is not None:\n            if event_type == \"add\":\n                answer.vote_count += 1\n            else:\n                answer.vote_count -= 1\n\n        self.dispatch(f\"raw_poll_vote_{event_type}\", raw)\n\n        if raw.cached_member is not None and answer is not None:\n            self.dispatch(f\"poll_vote_{event_type}\", raw.cached_member, answer)\n\n    def parse_message_poll_vote_add(self, data: gateway.PollVoteAddEvent) -> None:\n        raw = RawPollVoteActionEvent(data, \"POLL_VOTE_ADD\")\n        self._handle_poll_event(raw, \"add\")\n\n    def parse_message_poll_vote_remove(self, data: gateway.PollVoteRemoveEvent) -> None:\n        raw = RawPollVoteActionEvent(data, \"POLL_VOTE_REMOVE\")\n        self._handle_poll_event(raw, \"remove\")\n\n    def parse_interaction_create(self, data: gateway.InteractionCreateEvent) -> None:\n        # note: this does not use an intermediate variable for `data[\"type\"]` since\n        # it wouldn't allow automatically narrowing the `data` union type based\n        # on the `[\"type\"]` field\n\n        interaction: Interaction\n\n        if data[\"type\"] == 1:\n            # PING interaction should never be received\n            return\n\n        elif data[\"type\"] == 2:\n            interaction = ApplicationCommandInteraction(data=data, state=self)\n            self.dispatch(\"application_command\", interaction)\n\n        elif data[\"type\"] == 3:\n            interaction = MessageInteraction(data=data, state=self)\n            self._view_store.dispatch(interaction)\n            self.dispatch(\"message_interaction\", interaction)\n            if interaction.data.component_type is ComponentType.button:\n                self.dispatch(\"button_click\", interaction)\n            elif interaction.data.component_type in _SELECT_COMPONENT_TYPES:\n                self.dispatch(\"dropdown\", interaction)\n\n        elif data[\"type\"] == 4:\n            interaction = ApplicationCommandInteraction(data=data, state=self)\n            self.dispatch(\"application_command_autocomplete\", interaction)\n\n        elif data[\"type\"] == 5:\n            interaction = ModalInteraction(data=data, state=self)\n            self._modal_store.dispatch(interaction)\n            self.dispatch(\"modal_submit\", interaction)\n\n        else:\n            return\n\n        self.dispatch(\"interaction\", interaction)\n\n    def parse_presence_update(self, data: gateway.PresenceUpdateEvent) -> None:\n        guild_id = utils._get_as_snowflake(data, \"guild_id\")\n        guild = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\"PRESENCE_UPDATE referencing an unknown guild ID: %s. Discarding.\", guild_id)\n            return\n\n        raw = RawPresenceUpdateEvent(data)\n        self.dispatch(\"raw_presence_update\", raw)\n\n        user = data[\"user\"]\n        member_id = int(user[\"id\"])\n        member = guild.get_member(member_id)\n        if member is None:\n            return\n\n        old_member = Member._copy(member)\n        user_update = member._presence_update(data=data, user=user)\n        if user_update:\n            self.dispatch(\"user_update\", user_update[0], user_update[1])\n\n        self.dispatch(\"presence_update\", old_member, member)\n\n    def parse_user_update(self, data: gateway.UserUpdateEvent) -> None:\n        if user := self.user:\n            user._update(data)\n\n    def parse_invite_create(self, data: gateway.InviteCreateEvent) -> None:\n        invite = Invite.from_gateway(state=self, data=data)\n        self.dispatch(\"invite_create\", invite)\n\n    def parse_invite_delete(self, data: gateway.InviteDeleteEvent) -> None:\n        invite = Invite.from_gateway(state=self, data=data)\n        self.dispatch(\"invite_delete\", invite)\n\n    def parse_channel_delete(self, data: gateway.ChannelDeleteEvent) -> None:\n        guild = self._get_guild(utils._get_as_snowflake(data, \"guild_id\"))\n        if guild is None:\n            return\n\n        channel_id = int(data[\"id\"])\n        channel = guild.get_channel(channel_id)\n        if channel is None:\n            return\n\n        guild._remove_channel(channel)\n        self.dispatch(\"guild_channel_delete\", channel)\n\n        if channel.type in (ChannelType.voice, ChannelType.stage_voice):\n            for event_id, scheduled_event in list(guild._scheduled_events.items()):\n                if scheduled_event.channel_id == channel_id:\n                    guild._scheduled_events.pop(event_id)\n                    self.dispatch(\"guild_scheduled_event_delete\", scheduled_event)\n\n    def parse_channel_update(self, data: gateway.ChannelUpdateEvent) -> None:\n        channel_type = try_enum(ChannelType, data.get(\"type\"))\n        channel_id = int(data[\"id\"])\n        if channel_type is ChannelType.group:\n            channel = self._get_private_channel(channel_id)\n            old_channel = copy.copy(channel)\n            # the channel is a GroupChannel\n            channel._update_group(data)  # pyright: ignore[reportOptionalMemberAccess, reportAttributeAccessIssue]\n            self.dispatch(\"private_channel_update\", old_channel, channel)\n            return\n\n        guild_id = utils._get_as_snowflake(data, \"guild_id\")\n        guild = self._get_guild(guild_id)\n        if guild is not None:\n            channel = guild.get_channel(channel_id)\n            if channel is not None:\n                old_channel = copy.copy(channel)\n                channel._update(\n                    guild,\n                    data,  # pyright: ignore[reportArgumentType]  # data type will always match channel type\n                )\n                self.dispatch(\"guild_channel_update\", old_channel, channel)\n            else:\n                _log.debug(\n                    \"CHANNEL_UPDATE referencing an unknown channel ID: %s. Discarding.\", channel_id\n                )\n        else:\n            _log.debug(\"CHANNEL_UPDATE referencing an unknown guild ID: %s. Discarding.\", guild_id)\n\n    def parse_channel_create(self, data: gateway.ChannelCreateEvent) -> None:\n        factory, _ = _guild_channel_factory(data[\"type\"])\n        if factory is None:\n            _log.debug(\n                \"CHANNEL_CREATE referencing an unknown channel type %s. Discarding.\", data[\"type\"]\n            )\n            return\n\n        guild_id = utils._get_as_snowflake(data, \"guild_id\")\n        guild = self._get_guild(guild_id)\n        if guild is not None:\n            channel = factory(\n                guild=guild,\n                state=self,\n                data=data,  # pyright: ignore[reportArgumentType]  # data type will always match channel type\n            )\n            guild._add_channel(channel)\n            self.dispatch(\"guild_channel_create\", channel)\n        else:\n            _log.debug(\"CHANNEL_CREATE referencing an unknown guild ID: %s. Discarding.\", guild_id)\n            return\n\n    def parse_channel_pins_update(self, data: gateway.ChannelPinsUpdateEvent) -> None:\n        channel_id = int(data[\"channel_id\"])\n        guild_id = utils._get_as_snowflake(data, \"guild_id\")\n        if guild_id is not None:\n            guild = self._get_guild(guild_id)\n            channel = guild and guild._resolve_channel(channel_id)\n        else:\n            guild = None\n            channel = self._get_private_channel(channel_id)\n\n        if channel is None:\n            _log.debug(\n                \"CHANNEL_PINS_UPDATE referencing an unknown channel ID: %s. Discarding.\", channel_id\n            )\n            return\n\n        last_pin = None\n        if \"last_pin_timestamp\" in data:\n            last_pin = utils.parse_time(data[\"last_pin_timestamp\"])\n\n        if isinstance(channel, (DMChannel, TextChannel, Thread)):\n            channel.last_pin_timestamp = last_pin\n\n        if guild is None:\n            self.dispatch(\"private_channel_pins_update\", channel, last_pin)\n        else:\n            self.dispatch(\"guild_channel_pins_update\", channel, last_pin)\n\n    def parse_thread_create(self, data: gateway.ThreadCreateEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild: Guild | None = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\"THREAD_CREATE referencing an unknown guild ID: %s. Discarding\", guild_id)\n            return\n\n        thread = Thread(guild=guild, state=guild._state, data=data)\n        has_thread = guild.get_thread(thread.id)\n        guild._add_thread(thread)\n        if not has_thread:\n            if data.get(\"newly_created\"):\n                if isinstance(thread.parent, (ForumChannel, MediaChannel)):\n                    thread.parent.last_thread_id = thread.id\n\n                self.dispatch(\"thread_create\", thread)\n            else:\n                self.dispatch(\"thread_join\", thread)\n\n    def parse_thread_update(self, data: gateway.ThreadUpdateEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\"THREAD_UPDATE referencing an unknown guild ID: %s. Discarding\", guild_id)\n            return\n\n        thread_id = int(data[\"id\"])\n        thread = guild.get_thread(thread_id)\n        if thread is not None:\n            old = copy.copy(thread)\n            thread._update(data)\n            self.dispatch(\"thread_update\", old, thread)\n        else:\n            thread = Thread(guild=guild, state=guild._state, data=data)\n            guild._add_thread(thread)\n            self.dispatch(\"thread_join\", thread)\n\n        self.dispatch(\"raw_thread_update\", thread)\n\n    def parse_thread_delete(self, data: gateway.ThreadDeleteEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\"THREAD_DELETE referencing an unknown guild ID: %s. Discarding\", guild_id)\n            return\n\n        thread_id = int(data[\"id\"])\n        thread = guild.get_thread(thread_id)\n        raw = RawThreadDeleteEvent(data)\n        if thread is not None:\n            raw.thread = thread\n            guild._remove_thread(thread)\n            self.dispatch(\"thread_delete\", thread)\n        self.dispatch(\"raw_thread_delete\", raw)\n\n    def parse_thread_list_sync(self, data: gateway.ThreadListSyncEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild: Guild | None = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\"THREAD_LIST_SYNC referencing an unknown guild ID: %s. Discarding\", guild_id)\n            return\n\n        if \"channel_ids\" in data:\n            channel_ids = set(map(int, data[\"channel_ids\"]))\n            previous_threads = guild._filter_threads(channel_ids)\n        else:\n            # If not provided, then the entire guild is being synced\n            # So all previous thread data should be overwritten\n            previous_threads = guild._threads.copy()\n            guild._clear_threads()\n\n        threads = {d[\"id\"]: guild._store_thread(d) for d in data.get(\"threads\", [])}\n\n        for member in data.get(\"members\", []):\n            try:\n                # note: member[\"id\"] is the thread_id\n                thread = threads[member[\"id\"]]\n            except KeyError:\n                continue\n            else:\n                thread._add_member(ThreadMember(thread, member))\n\n        for thread in threads.values():\n            old = previous_threads.pop(thread.id, None)\n            if old is None:\n                self.dispatch(\"thread_join\", thread)\n\n        for thread in previous_threads.values():\n            self.dispatch(\"thread_remove\", thread)\n\n    def parse_thread_member_update(self, data: gateway.ThreadMemberUpdateEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild: Guild | None = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\n                \"THREAD_MEMBER_UPDATE referencing an unknown guild ID: %s. Discarding\", guild_id\n            )\n            return\n\n        thread_id = int(data[\"id\"])\n        thread: Thread | None = guild.get_thread(thread_id)\n        if thread is None:\n            _log.debug(\n                \"THREAD_MEMBER_UPDATE referencing an unknown thread ID: %s. Discarding\", thread_id\n            )\n            return\n\n        member = ThreadMember(thread, data)\n        thread.me = member\n\n    def parse_thread_members_update(self, data: gateway.ThreadMembersUpdateEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild: Guild | None = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\n                \"THREAD_MEMBERS_UPDATE referencing an unknown guild ID: %s. Discarding\", guild_id\n            )\n            return\n\n        thread_id = int(data[\"id\"])\n        thread: Thread | None = guild.get_thread(thread_id)\n        if thread is None:\n            _log.debug(\n                \"THREAD_MEMBERS_UPDATE referencing an unknown thread ID: %s. Discarding\", thread_id\n            )\n            return\n\n        added_members = [ThreadMember(thread, d) for d in data.get(\"added_members\", [])]\n        removed_member_ids = [int(x) for x in data.get(\"removed_member_ids\", [])]\n        self_id = self.self_id\n        for member in added_members:\n            if member.id != self_id:\n                thread._add_member(member)\n                self.dispatch(\"thread_member_join\", member)\n            else:\n                thread.me = member\n                self.dispatch(\"thread_join\", thread)\n\n        for member_id in removed_member_ids:\n            if member_id != self_id:\n                raw = RawThreadMemberRemoveEvent(thread, member_id)\n                member = thread._pop_member(member_id)\n                if member is not None:\n                    raw.cached_member = member\n                    self.dispatch(\"thread_member_remove\", member)\n                self.dispatch(\"raw_thread_member_remove\", raw)\n            else:\n                self.dispatch(\"thread_remove\", thread)\n\n    def parse_guild_member_add(self, data: gateway.GuildMemberAddEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"GUILD_MEMBER_ADD referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        member = Member(guild=guild, data=data, state=self)\n        if self.member_cache_flags.joined:\n            guild._add_member(member)\n\n        try:\n            guild._member_count += 1\n        except AttributeError:\n            pass\n\n        self.dispatch(\"member_join\", member)\n\n    def parse_guild_member_remove(self, data: gateway.GuildMemberRemoveEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None:\n            try:\n                guild._member_count -= 1\n            except AttributeError:\n                pass\n\n            user_id = int(data[\"user\"][\"id\"])\n            member = guild.get_member(user_id)\n            if member is not None:\n                guild._remove_member(member)\n                self.dispatch(\"member_remove\", member)\n                user = member\n            else:\n                user = self.store_user(data[\"user\"])\n            raw = RawGuildMemberRemoveEvent(user, guild.id)\n            self.dispatch(\"raw_member_remove\", raw)\n        else:\n            _log.debug(\n                \"GUILD_MEMBER_REMOVE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n\n    def parse_guild_member_update(self, data: gateway.GuildMemberUpdateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        user_id = int(data[\"user\"][\"id\"])\n        if guild is None:\n            _log.debug(\n                \"GUILD_MEMBER_UPDATE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        member = guild.get_member(user_id)\n        if member is not None:\n            old_member = Member._copy(member)\n            member._update(data)\n            user_update = member._update_inner_user(data[\"user\"])\n            if user_update:\n                self.dispatch(\"user_update\", user_update[0], user_update[1])\n\n            self.dispatch(\"member_update\", old_member, member)\n        else:\n            member = Member(data=data, guild=guild, state=self)\n\n            # Force an update on the inner user if necessary\n            user_update = member._update_inner_user(data[\"user\"])\n            if user_update:\n                self.dispatch(\"user_update\", user_update[0], user_update[1])\n\n            if self.member_cache_flags.joined:\n                guild._add_member(member)\n\n        self.dispatch(\"raw_member_update\", member)\n\n    def parse_guild_emojis_update(self, data: gateway.GuildEmojisUpdateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"GUILD_EMOJIS_UPDATE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        before_emojis = guild.emojis\n        for emoji in before_emojis:\n            self._emojis.pop(emoji.id, None)\n        guild.emojis = tuple(self.store_emoji(guild, d) for d in data[\"emojis\"])\n        self.dispatch(\"guild_emojis_update\", guild, before_emojis, guild.emojis)\n\n    def parse_guild_stickers_update(self, data: gateway.GuildStickersUpdateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"GUILD_STICKERS_UPDATE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        before_stickers = guild.stickers\n        for sticker in before_stickers:\n            self._stickers.pop(sticker.id, None)\n        guild.stickers = tuple(self.store_sticker(guild, d) for d in data[\"stickers\"])\n        self.dispatch(\"guild_stickers_update\", guild, before_stickers, guild.stickers)\n\n    def _get_create_guild(self, data: gateway.GuildCreateEvent) -> Guild:\n        if data.get(\"unavailable\") is False:\n            # GUILD_CREATE with unavailable in the response\n            # usually means that the guild has become available\n            # and is therefore in the cache\n            guild = self._get_guild(int(data[\"id\"]))\n            if guild is not None:\n                guild.unavailable = False\n                guild._from_data(data)  # pyright: ignore[reportArgumentType]  # data type not narrowed correctly to full guild\n                return guild\n\n        return self._add_guild_from_data(data)\n\n    def is_guild_evicted(self, guild) -> bool:\n        return guild.id not in self._guilds\n\n    @overload\n    async def chunk_guild(\n        self, guild: Guild, *, wait: Literal[False], cache: bool | None = None\n    ) -> asyncio.Future[list[Member]]: ...\n\n    @overload\n    async def chunk_guild(\n        self, guild: Guild, *, wait: Literal[True] = True, cache: bool | None = None\n    ) -> list[Member]: ...\n\n    async def chunk_guild(\n        self, guild: Guild, *, wait: bool = True, cache: bool | None = None\n    ) -> list[Member] | asyncio.Future[list[Member]]:\n        cache = cache or self.member_cache_flags.joined\n        request = self._chunk_requests.get(guild.id)\n        if request is None:\n            self._chunk_requests[guild.id] = request = ChunkRequest(\n                guild.id, self.loop, self._get_guild, cache=cache\n            )\n            await self.chunker(guild.id, nonce=request.nonce)\n\n        if wait:\n            return await request.wait()\n        return request.get_future()\n\n    async def _chunk_and_dispatch(self, guild: Guild, unavailable: bool | None) -> None:\n        try:\n            await asyncio.wait_for(self.chunk_guild(guild), timeout=60.0)\n        except asyncio.TimeoutError:\n            _log.info(\"Somehow timed out waiting for chunks.\")\n\n        if unavailable is False:\n            self.dispatch(\"guild_available\", guild)\n        else:\n            self.dispatch(\"guild_join\", guild)\n\n    def parse_guild_create(self, data: gateway.GuildCreateEvent) -> None:\n        unavailable = data.get(\"unavailable\")\n        if unavailable is True:\n            # joined a guild with unavailable == True so..\n            return\n\n        guild = self._get_create_guild(data)\n\n        try:\n            # Notify the on_ready state, if any, that this guild is complete.\n            self._ready_state.put_nowait(guild)\n        except AttributeError:\n            pass\n        else:\n            # If we're waiting for the event, put the rest on hold\n            return\n\n        # check if it requires chunking\n        if self._guild_needs_chunking(guild):\n            asyncio.create_task(self._chunk_and_dispatch(guild, unavailable))\n            return\n\n        # Dispatch available if newly available\n        if unavailable is False:\n            self.dispatch(\"guild_available\", guild)\n        else:\n            self.dispatch(\"guild_join\", guild)\n\n    def parse_guild_update(self, data: gateway.GuildUpdateEvent) -> None:\n        guild = self._get_guild(int(data[\"id\"]))\n        if guild is not None:\n            old_guild = copy.copy(guild)\n            guild._from_data(data)\n            self.dispatch(\"guild_update\", old_guild, guild)\n        else:\n            _log.debug(\"GUILD_UPDATE referencing an unknown guild ID: %s. Discarding.\", data[\"id\"])\n\n    def parse_guild_delete(self, data: gateway.GuildDeleteEvent) -> None:\n        guild = self._get_guild(int(data[\"id\"]))\n        if guild is None:\n            _log.debug(\"GUILD_DELETE referencing an unknown guild ID: %s. Discarding.\", data[\"id\"])\n            return\n\n        if data.get(\"unavailable\", False):\n            # GUILD_DELETE with unavailable being True means that the\n            # guild that was available is now currently unavailable\n            guild.unavailable = True\n            self.dispatch(\"guild_unavailable\", guild)\n            return\n\n        # do a cleanup of the messages cache\n        if self._messages is not None:\n            self._messages: deque[Message] | None = deque(\n                (msg for msg in self._messages if msg.guild != guild), maxlen=self.max_messages\n            )\n\n        self._remove_guild(guild)\n        self.dispatch(\"guild_remove\", guild)\n\n    def parse_guild_ban_add(self, data: gateway.GuildBanAddEvent) -> None:\n        # we make the assumption that GUILD_BAN_ADD is done\n        # before GUILD_MEMBER_REMOVE is called\n        # hence we don't remove it from cache or do anything\n        # strange with it, the main purpose of this event\n        # is mainly to dispatch to another event worth listening to for logging\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None:\n            try:\n                user = User(data=data[\"user\"], state=self)\n            except KeyError:\n                pass\n            else:\n                member = guild.get_member(user.id) or user\n                self.dispatch(\"member_ban\", guild, member)\n\n    def parse_guild_ban_remove(self, data: gateway.GuildBanRemoveEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None and \"user\" in data:\n            user = self.store_user(data[\"user\"])\n            self.dispatch(\"member_unban\", guild, user)\n\n    def parse_guild_role_create(self, data: gateway.GuildRoleCreateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"GUILD_ROLE_CREATE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        role_data = data[\"role\"]\n        role = Role(guild=guild, data=role_data, state=self)\n        guild._add_role(role)\n        self.dispatch(\"guild_role_create\", role)\n\n    def parse_guild_role_delete(self, data: gateway.GuildRoleDeleteEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None:\n            role_id = int(data[\"role_id\"])\n            try:\n                role = guild._remove_role(role_id)\n            except KeyError:\n                return\n            else:\n                self.dispatch(\"guild_role_delete\", role)\n        else:\n            _log.debug(\n                \"GUILD_ROLE_DELETE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n\n    def parse_guild_role_update(self, data: gateway.GuildRoleUpdateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None:\n            role_data = data[\"role\"]\n            role_id = int(role_data[\"id\"])\n            role = guild.get_role(role_id)\n            if role is not None:\n                old_role = copy.copy(role)\n                role._update(role_data)\n                self.dispatch(\"guild_role_update\", old_role, role)\n        else:\n            _log.debug(\n                \"GUILD_ROLE_UPDATE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n\n    def parse_guild_scheduled_event_create(\n        self, data: gateway.GuildScheduledEventCreateEvent\n    ) -> None:\n        scheduled_event = GuildScheduledEvent(state=self, data=data)\n        guild = scheduled_event.guild\n        if guild is not None:\n            guild._scheduled_events[scheduled_event.id] = scheduled_event\n        self.dispatch(\"guild_scheduled_event_create\", scheduled_event)\n\n    def parse_guild_scheduled_event_update(\n        self, data: gateway.GuildScheduledEventUpdateEvent\n    ) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n\n        if guild is None:\n            _log.debug(\n                \"GUILD_SCHEDULED_EVENT_UPDATE referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        scheduled_event = guild._scheduled_events.get(int(data[\"id\"]))\n        if scheduled_event is not None:\n            old_scheduled_event = copy.copy(scheduled_event)\n            scheduled_event._update(data)\n            self.dispatch(\"guild_scheduled_event_update\", old_scheduled_event, scheduled_event)\n\n        else:\n            _log.debug(\n                \"GUILD_SCHEDULED_EVENT_UPDATE referencing \"\n                \"unknown scheduled event ID: %s. Discarding.\",\n                data[\"id\"],\n            )\n\n    def parse_guild_scheduled_event_delete(\n        self, data: gateway.GuildScheduledEventDeleteEvent\n    ) -> None:\n        scheduled_event = GuildScheduledEvent(state=self, data=data)\n        guild = scheduled_event.guild\n        if guild is not None:\n            guild._scheduled_events.pop(scheduled_event.id, None)\n        self.dispatch(\"guild_scheduled_event_delete\", scheduled_event)\n\n    def parse_guild_scheduled_event_user_add(\n        self, data: gateway.GuildScheduledEventUserAddEvent\n    ) -> None:\n        payload = RawGuildScheduledEventUserActionEvent(data)\n        self.dispatch(\"raw_guild_scheduled_event_subscribe\", payload)\n        guild = self._get_guild(payload.guild_id)\n        if guild is None:\n            return\n\n        event = guild.get_scheduled_event(payload.event_id)\n        user = guild.get_member(payload.user_id)\n        if user is None:\n            user = self.get_user(payload.user_id)\n\n        if event is not None and user is not None:\n            self.dispatch(\"guild_scheduled_event_subscribe\", event, user)\n\n    def parse_guild_scheduled_event_user_remove(\n        self, data: gateway.GuildScheduledEventUserRemoveEvent\n    ) -> None:\n        payload = RawGuildScheduledEventUserActionEvent(data)\n        self.dispatch(\"raw_guild_scheduled_event_unsubscribe\", payload)\n        guild = self._get_guild(payload.guild_id)\n        if guild is None:\n            return\n\n        event = guild.get_scheduled_event(payload.event_id)\n        user = guild.get_member(payload.user_id)\n        if user is None:\n            user = self.get_user(payload.user_id)\n\n        if event is not None and user is not None:\n            self.dispatch(\"guild_scheduled_event_unsubscribe\", event, user)\n\n    def parse_guild_members_chunk(self, data: gateway.GuildMembersChunkEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild = self._get_guild(guild_id)\n        # This should never happen, but it's handled just in case\n        if guild is None:\n            _log.debug(\n                \"GUILD_MEMBERS_CHUNK referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        presences = data.get(\"presences\", [])\n\n        members = [\n            Member(guild=guild, data=member, state=self) for member in data.get(\"members\", [])\n        ]\n        _log.debug(\"Processed a chunk for %s members in guild ID %s.\", len(members), guild_id)\n\n        if presences:\n            member_dict = {member.id: member for member in members}\n            for presence in presences:\n                user = presence[\"user\"]\n                member_id = int(user[\"id\"])\n                member = member_dict.get(member_id)\n                if member is not None:\n                    member._presence_update(presence, user)\n\n        complete = data.get(\"chunk_index\", 0) + 1 == data.get(\"chunk_count\")\n        self.process_chunk_requests(guild_id, data.get(\"nonce\"), members, complete)\n\n    def parse_guild_integrations_update(self, data: gateway.GuildIntegrationsUpdateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None:\n            self.dispatch(\"guild_integrations_update\", guild)\n        else:\n            _log.debug(\n                \"GUILD_INTEGRATIONS_UPDATE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n\n    def parse_integration_create(self, data: gateway.IntegrationCreateEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild = self._get_guild(guild_id)\n        if guild is not None:\n            cls, _ = _integration_factory(data[\"type\"])\n            integration = cls(data=data, guild=guild)\n            self.dispatch(\"integration_create\", integration)\n        else:\n            _log.debug(\n                \"INTEGRATION_CREATE referencing an unknown guild ID: %s. Discarding.\", guild_id\n            )\n\n    def parse_integration_update(self, data: gateway.IntegrationUpdateEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild = self._get_guild(guild_id)\n        if guild is not None:\n            cls, _ = _integration_factory(data[\"type\"])\n            integration = cls(data=data, guild=guild)\n            self.dispatch(\"integration_update\", integration)\n        else:\n            _log.debug(\n                \"INTEGRATION_UPDATE referencing an unknown guild ID: %s. Discarding.\", guild_id\n            )\n\n    def parse_integration_delete(self, data: gateway.IntegrationDeleteEvent) -> None:\n        guild_id = int(data[\"guild_id\"])\n        guild = self._get_guild(guild_id)\n        if guild is not None:\n            raw = RawIntegrationDeleteEvent(data)\n            self.dispatch(\"raw_integration_delete\", raw)\n        else:\n            _log.debug(\n                \"INTEGRATION_DELETE referencing an unknown guild ID: %s. Discarding.\", guild_id\n            )\n\n    def parse_webhooks_update(self, data: gateway.WebhooksUpdateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"WEBHOOKS_UPDATE referencing an unknown guild ID: %s. Discarding\", data[\"guild_id\"]\n            )\n            return\n\n        channel = guild.get_channel(int(data[\"channel_id\"]))\n        if channel is not None:\n            self.dispatch(\"webhooks_update\", channel)\n        else:\n            _log.debug(\n                \"WEBHOOKS_UPDATE referencing an unknown channel ID: %s. Discarding.\",\n                data[\"channel_id\"],\n            )\n\n    def parse_stage_instance_create(self, data: gateway.StageInstanceCreateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None:\n            stage_instance = StageInstance(guild=guild, state=self, data=data)\n            guild._stage_instances[stage_instance.id] = stage_instance\n            self.dispatch(\"stage_instance_create\", stage_instance)\n        else:\n            _log.debug(\n                \"STAGE_INSTANCE_CREATE referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n\n    def parse_stage_instance_update(self, data: gateway.StageInstanceUpdateEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None:\n            stage_instance = guild._stage_instances.get(int(data[\"id\"]))\n            if stage_instance is not None:\n                old_stage_instance = copy.copy(stage_instance)\n                stage_instance._update(data)\n                self.dispatch(\"stage_instance_update\", old_stage_instance, stage_instance)\n            else:\n                _log.debug(\n                    \"STAGE_INSTANCE_UPDATE referencing unknown stage instance ID: %s. Discarding.\",\n                    data[\"id\"],\n                )\n        else:\n            _log.debug(\n                \"STAGE_INSTANCE_UPDATE referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n\n    def parse_stage_instance_delete(self, data: gateway.StageInstanceDeleteEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is not None:\n            try:\n                stage_instance = guild._stage_instances.pop(int(data[\"id\"]))\n            except KeyError:\n                pass\n            else:\n                self.dispatch(\"stage_instance_delete\", stage_instance)\n        else:\n            _log.debug(\n                \"STAGE_INSTANCE_DELETE referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n\n    def parse_voice_state_update(self, data: gateway.VoiceStateUpdateEvent) -> None:\n        guild = self._get_guild(utils._get_as_snowflake(data, \"guild_id\"))\n        channel_id = utils._get_as_snowflake(data, \"channel_id\")\n        flags = self.member_cache_flags\n        # self.user is *always* cached when this is called\n        self_id = self.user.id\n        if guild is not None:\n            if int(data[\"user_id\"]) == self_id:\n                voice = self._get_voice_client(guild.id)\n                if voice is not None:\n                    coro = voice.on_voice_state_update(data)\n                    asyncio.create_task(\n                        logging_coroutine(coro, info=\"Voice Protocol voice state update handler\")\n                    )\n\n            member, before, after = guild._update_voice_state(data, channel_id)\n            if member is not None:\n                if flags.voice:\n                    if channel_id is None and flags._voice_only and member.id != self_id:\n                        # Only remove from cache if we only have the voice flag enabled\n                        guild._remove_member(member)\n                    elif channel_id is not None:\n                        guild._add_member(member)\n\n                self.dispatch(\"voice_state_update\", member, before, after)\n            else:\n                _log.debug(\n                    \"VOICE_STATE_UPDATE referencing an unknown member ID: %s. Discarding.\",\n                    data[\"user_id\"],\n                )\n\n    def parse_voice_server_update(self, data: gateway.VoiceServerUpdateEvent) -> None:\n        key_id = int(data[\"guild_id\"])\n\n        vc = self._get_voice_client(key_id)\n        if vc is not None:\n            coro = vc.on_voice_server_update(data)\n            asyncio.create_task(\n                logging_coroutine(coro, info=\"Voice Protocol voice server update handler\")\n            )\n\n    def parse_voice_channel_effect_send(self, data: gateway.VoiceChannelEffectSendEvent) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"VOICE_CHANNEL_EFFECT_SEND referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        effect = VoiceChannelEffect(data=data, state=self)\n        raw = RawVoiceChannelEffectEvent(data, effect)\n\n        channel = guild.get_channel(raw.channel_id)\n        raw.cached_member = member = guild.get_member(raw.user_id)\n        self.dispatch(\"raw_voice_channel_effect\", raw)\n\n        if channel and member:\n            self.dispatch(\"voice_channel_effect\", channel, member, effect)\n\n    # FIXME: this should be refactored. The `GroupChannel` path will never be hit,\n    # `raw.timestamp` exists so no need to parse it twice, and `.get_user` should be used before falling back\n    def parse_typing_start(self, data: gateway.TypingStartEvent) -> None:\n        channel, guild = self._get_guild_channel(data)\n        raw = RawTypingEvent(data)\n\n        user_id = int(data[\"user_id\"])\n        member_data = data.get(\"member\")\n        if member_data and guild is not None:\n            # try member cache first\n            raw.member = guild.get_member(user_id) or Member(\n                data=member_data, guild=guild, state=self\n            )\n\n        self.dispatch(\"raw_typing\", raw)\n\n        if channel is not None:  # pyright: ignore[reportUnnecessaryComparison]\n            member = None\n            if raw.member is not None:\n                member = raw.member\n\n            elif isinstance(channel, DMChannel):\n                member = channel.recipient\n\n            elif isinstance(channel, GroupChannel):\n                member = utils.find(lambda x: x.id == user_id, channel.recipients)\n\n            if member is not None:\n                timestamp = datetime.datetime.fromtimestamp(\n                    data[\"timestamp\"], tz=datetime.timezone.utc\n                )\n                self.dispatch(\"typing\", channel, member, timestamp)\n\n    def parse_auto_moderation_rule_create(\n        self, data: gateway.AutoModerationRuleCreateEvent\n    ) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"AUTO_MODERATION_RULE_CREATE referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        rule = AutoModRule(data=data, guild=guild)\n        self.dispatch(\"automod_rule_create\", rule)\n\n    def parse_auto_moderation_rule_update(\n        self, data: gateway.AutoModerationRuleUpdateEvent\n    ) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"AUTO_MODERATION_RULE_UPDATE referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        rule = AutoModRule(data=data, guild=guild)\n        self.dispatch(\"automod_rule_update\", rule)\n\n    def parse_auto_moderation_rule_delete(\n        self, data: gateway.AutoModerationRuleDeleteEvent\n    ) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"AUTO_MODERATION_RULE_DELETE referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        rule = AutoModRule(data=data, guild=guild)\n        self.dispatch(\"automod_rule_delete\", rule)\n\n    def parse_auto_moderation_action_execution(\n        self, data: gateway.AutoModerationActionExecutionEvent\n    ) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"AUTO_MODERATION_ACTION_EXECUTION referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        event = AutoModActionExecution(data=data, guild=guild)\n        self.dispatch(\"automod_action_execution\", event)\n\n    def parse_guild_audit_log_entry_create(self, data: gateway.AuditLogEntryCreate) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"GUILD_AUDIT_LOG_ENTRY_CREATE referencing unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        entry = AuditLogEntry(\n            data=data,\n            guild=guild,\n            application_commands={},\n            automod_rules={},\n            guild_scheduled_events=guild._scheduled_events,\n            integrations={},\n            threads=guild._threads,\n            users=self._users,\n            webhooks={},\n        )\n        self.dispatch(\"audit_log_entry_create\", entry)\n\n    def parse_entitlement_create(self, data: gateway.EntitlementCreate) -> None:\n        entitlement = Entitlement(data=data, state=self)\n        self.dispatch(\"entitlement_create\", entitlement)\n\n    def parse_entitlement_update(self, data: gateway.EntitlementUpdate) -> None:\n        entitlement = Entitlement(data=data, state=self)\n        self.dispatch(\"entitlement_update\", entitlement)\n\n    def parse_entitlement_delete(self, data: gateway.EntitlementDelete) -> None:\n        entitlement = Entitlement(data=data, state=self)\n        self.dispatch(\"entitlement_delete\", entitlement)\n\n    def parse_subscription_create(self, data: gateway.SubscriptionCreate) -> None:\n        subscription = Subscription(data=data, state=self)\n        self.dispatch(\"subscription_create\", subscription)\n\n    def parse_subscription_update(self, data: gateway.SubscriptionUpdate) -> None:\n        subscription = Subscription(data=data, state=self)\n        self.dispatch(\"subscription_update\", subscription)\n\n    def parse_subscription_delete(self, data: gateway.SubscriptionDelete) -> None:\n        subscription = Subscription(data=data, state=self)\n        self.dispatch(\"subscription_delete\", subscription)\n\n    def parse_guild_soundboard_sound_create(self, data: gateway.GuildSoundboardSoundCreate) -> None:\n        guild_id = utils._get_as_snowflake(data, \"guild_id\")\n        guild = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\n                \"GUILD_SOUNDBOARD_SOUND_CREATE referencing unknown guild ID: %s. Discarding.\",\n                guild_id,\n            )\n            return\n\n        sound = self.store_soundboard_sound(guild, data)\n\n        # since both single-target `SOUND_CREATE`/`_UPDATE`/`_DELETE`s and a generic `SOUNDS_UPDATE`\n        # exist, turn these events into synthetic `SOUNDS_UPDATE`s\n        self._handle_soundboard_update(\n            guild,\n            # append new sound\n            (*guild.soundboard_sounds, sound),\n        )\n\n    def parse_guild_soundboard_sound_update(self, data: gateway.GuildSoundboardSoundUpdate) -> None:\n        guild_id = utils._get_as_snowflake(data, \"guild_id\")\n        guild = self._get_guild(guild_id)\n        if guild is None:\n            _log.debug(\n                \"GUILD_SOUNDBOARD_SOUND_UPDATE referencing an unknown guild ID: %s. Discarding.\",\n                guild_id,\n            )\n            return\n\n        sound_id = int(data[\"sound_id\"])\n        sound = self.get_soundboard_sound(sound_id)\n        if sound is None:\n            _log.debug(\n                \"GUILD_SOUNDBOARD_SOUND_UPDATE referencing unknown sound ID: %s. Discarding.\",\n                sound_id,\n            )\n            return\n\n        self._soundboard_sounds.pop(sound.id, None)\n        new_sound = self.store_soundboard_sound(guild, data)\n\n        self._handle_soundboard_update(\n            guild,\n            # replace sound in tuple at same position\n            tuple((new_sound if s.id == sound.id else s) for s in guild.soundboard_sounds),\n        )\n\n    def parse_guild_soundboard_sound_delete(self, data: gateway.GuildSoundboardSoundDelete) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"GUILD_SOUNDBOARD_SOUND_DELETE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        sound_id = int(data[\"sound_id\"])\n        sound = self.get_soundboard_sound(sound_id)\n        if sound is None:\n            _log.debug(\n                \"GUILD_SOUNDBOARD_SOUND_UPDATE referencing unknown sound ID: %s. Discarding.\",\n                sound_id,\n            )\n            return\n\n        self._soundboard_sounds.pop(sound.id, None)\n\n        self._handle_soundboard_update(\n            guild,\n            # remove sound from tuple\n            tuple(s for s in guild.soundboard_sounds if s.id != sound.id),\n        )\n\n    def parse_guild_soundboard_sounds_update(\n        self, data: gateway.GuildSoundboardSoundsUpdate\n    ) -> None:\n        guild = self._get_guild(int(data[\"guild_id\"]))\n        if guild is None:\n            _log.debug(\n                \"GUILD_SOUNDBOARD_SOUNDS_UPDATE referencing an unknown guild ID: %s. Discarding.\",\n                data[\"guild_id\"],\n            )\n            return\n\n        for sound in guild.soundboard_sounds:\n            self._soundboard_sounds.pop(sound.id, None)\n\n        self._handle_soundboard_update(\n            guild,\n            tuple(self.store_soundboard_sound(guild, d) for d in data[\"soundboard_sounds\"]),\n        )\n\n    def _handle_soundboard_update(\n        self, guild: Guild, new_sounds: tuple[GuildSoundboardSound, ...]\n    ) -> None:\n        before_sounds = guild.soundboard_sounds\n        guild.soundboard_sounds = new_sounds\n\n        self.dispatch(\"guild_soundboard_sounds_update\", guild, before_sounds, new_sounds)\n\n    def _get_reaction_user(self, channel: MessageableChannel, user_id: int) -> User | Member | None:\n        if isinstance(channel, (TextChannel, VoiceChannel, Thread, StageChannel)):\n            return channel.guild.get_member(user_id)\n        return self.get_user(user_id)\n\n    # methods to handle all sorts of different emoji formats\n\n    def _get_emoji_from_data(self, data: PartialEmojiPayload) -> str | Emoji | PartialEmoji | None:\n        \"\"\"Convert partial emoji data to proper emoji.\n        Returns unicode emojis as strings.\n\n        Primarily used to handle reaction emojis.\n        \"\"\"\n        emoji_id = utils._get_as_snowflake(data, \"id\")\n        if not emoji_id:\n            return data[\"name\"]\n\n        if (emoji := self._emojis.get(emoji_id)) is not None:\n            return emoji\n\n        return PartialEmoji.with_state(\n            self,\n            # This may be `None` when custom emoji data in reactions isn't available.\n            # Should generally be fine, since we have an id at this point.\n            name=data[\"name\"],  # pyright: ignore[reportArgumentType]\n            id=emoji_id,\n            animated=data.get(\"animated\", False),\n        )\n\n    # deprecated\n    get_reaction_emoji = _get_emoji_from_data\n\n    def _get_emoji_from_fields(\n        self,\n        *,\n        name: str | None,\n        id: int | None,\n        animated: bool | None = False,\n    ) -> Emoji | PartialEmoji | None:\n        \"\"\"Convert partial emoji fields to proper emoji, if possible.\n        If both ``id`` and ``name`` are nullish, returns :data:`None`.\n\n        Unlike _get_emoji_from_data, this returns `PartialEmoji`s instead of strings\n        for unicode emojis, and falls back to \"\" for the emoji name.\n\n        Primarily used for structures with nonstandard top-level `emoji_name` and `emoji_id` fields,\n        like forum channels/tags or welcome screens.\n        \"\"\"\n        if not (name or id):\n            return None\n\n        if id and (emoji := self._emojis.get(id)) is not None:\n            return emoji\n\n        return PartialEmoji.with_state(\n            self,\n            # Note: this does not render correctly if it's a custom emoji, there's just no name information here sometimes.\n            # This may change in a future API version, but for now we'll just have to accept it.\n            name=name or \"\",\n            # Coerce `0` to `None`, occasional API inconsistency\n            id=id or None,\n            animated=animated or False,\n        )\n\n    def _upgrade_partial_emoji(self, emoji: PartialEmoji) -> Emoji | PartialEmoji | str:\n        emoji_id = emoji.id\n        if not emoji_id:\n            return emoji.name\n        try:\n            return self._emojis[emoji_id]\n        except KeyError:\n            return emoji\n\n    @overload\n    def _get_partial_interaction_channel(\n        self,\n        data: InteractionChannelPayload,\n        guild: Guild | Object | None,\n        *,\n        return_messageable: Literal[False] = False,\n    ) -> AnyChannel: ...\n\n    @overload\n    def _get_partial_interaction_channel(\n        self,\n        data: InteractionChannelPayload,\n        guild: Guild | Object | None,\n        *,\n        return_messageable: Literal[True],\n    ) -> MessageableChannel: ...\n\n    # note: this resolves unknown types to `PartialMessageable`\n    def _get_partial_interaction_channel(\n        self,\n        data: InteractionChannelPayload,\n        guild: Guild | Object | None,\n        *,\n        # this param is purely for type-checking, it has no effect on runtime behavior.\n        return_messageable: bool = False,\n    ) -> AnyChannel:\n        channel_id = int(data[\"id\"])\n        channel_type = data[\"type\"]\n\n        factory, ch_type = _threaded_channel_factory(channel_type)\n        if not factory:\n            return PartialMessageable(\n                state=self,\n                id=channel_id,\n                type=ch_type,\n            )\n\n        if ch_type in (ChannelType.group, ChannelType.private):\n            return (  # pyright: ignore[reportReturnType]\n                self._get_private_channel(channel_id)\n                # the factory will be a DMChannel or GroupChannel here\n                or factory(  # pyright: ignore[reportCallIssue]\n                    me=self.user,  # pyright: ignore[reportCallIssue]\n                    data=data,  # pyright: ignore[reportArgumentType]\n                    state=self,\n                )\n            )\n\n        # the factory can't be a DMChannel or GroupChannel here\n        data.setdefault(\"position\", 0)  # pyright: ignore[reportArgumentType, reportCallIssue]\n        return (isinstance(guild, Guild) and guild.get_channel_or_thread(channel_id)) or factory(\n            guild=guild,  # pyright: ignore[reportArgumentType, reportCallIssue]  # FIXME: create proper fallback guild instead of passing Object\n            state=self,\n            data=data,  # pyright: ignore[reportArgumentType]  # generic payload type\n        )\n\n    def get_channel(self, id: int | None) -> Channel | Thread | None:\n        if id is None:\n            return None\n\n        pm = self._get_private_channel(id)\n        if pm is not None:\n            return pm\n\n        for guild in self.guilds:\n            channel = guild._resolve_channel(id)\n            if channel is not None:\n                return channel\n        return None\n\n    def create_message(\n        self,\n        *,\n        channel: MessageableChannel,\n        data: MessagePayload,\n    ) -> Message:\n        return Message(state=self, channel=channel, data=data)\n\n    def create_webhook(self, data: WebhookPayload) -> Webhook:\n        return Webhook.from_state(data=data, state=self)\n\n    # Application commands (global)\n    # All these methods (except fetchers) update the application command cache as well,\n    # since there're no events related to application command updates\n\n    async def fetch_global_commands(\n        self,\n        *,\n        with_localizations: bool = True,\n    ) -> list[APIApplicationCommand]:\n        assert self.application_id is not None\n        results = await self.http.get_global_commands(\n            self.application_id, with_localizations=with_localizations\n        )\n        return [application_command_factory(data) for data in results]\n\n    async def fetch_global_command(self, command_id: int) -> APIApplicationCommand:\n        assert self.application_id is not None\n        result = await self.http.get_global_command(self.application_id, command_id)\n        return application_command_factory(result)\n\n    async def create_global_command(\n        self, application_command: ApplicationCommand\n    ) -> APIApplicationCommand:\n        assert self.application_id is not None\n        result = await self.http.upsert_global_command(\n            self.application_id, application_command.to_dict()\n        )\n        cmd = application_command_factory(result)\n        self._add_global_application_command(cmd)\n        return cmd\n\n    async def edit_global_command(\n        self, command_id: int, new_command: ApplicationCommand\n    ) -> APIApplicationCommand:\n        assert self.application_id is not None\n        result = await self.http.edit_global_command(\n            self.application_id, command_id, new_command.to_dict()\n        )\n        cmd = application_command_factory(result)\n        self._add_global_application_command(cmd)\n        return cmd\n\n    async def delete_global_command(self, command_id: int) -> None:\n        assert self.application_id is not None\n        await self.http.delete_global_command(self.application_id, command_id)\n        self._remove_global_application_command(command_id)\n\n    async def bulk_overwrite_global_commands(\n        self, application_commands: list[ApplicationCommand]\n    ) -> list[APIApplicationCommand]:\n        assert self.application_id is not None\n        payload = [cmd.to_dict() for cmd in application_commands]\n        results = await self.http.bulk_upsert_global_commands(self.application_id, payload)\n        commands = [application_command_factory(data) for data in results]\n        self._global_application_commands = {cmd.id: cmd for cmd in commands}\n        return commands\n\n    # Application commands (guild)\n\n    async def fetch_guild_commands(\n        self,\n        guild_id: int,\n        *,\n        with_localizations: bool = True,\n    ) -> list[APIApplicationCommand]:\n        assert self.application_id is not None\n        results = await self.http.get_guild_commands(\n            self.application_id, guild_id, with_localizations=with_localizations\n        )\n        return [application_command_factory(data) for data in results]\n\n    async def fetch_guild_command(self, guild_id: int, command_id: int) -> APIApplicationCommand:\n        assert self.application_id is not None\n        result = await self.http.get_guild_command(self.application_id, guild_id, command_id)\n        return application_command_factory(result)\n\n    async def create_guild_command(\n        self, guild_id: int, application_command: ApplicationCommand\n    ) -> APIApplicationCommand:\n        assert self.application_id is not None\n        result = await self.http.upsert_guild_command(\n            self.application_id, guild_id, application_command.to_dict()\n        )\n        cmd = application_command_factory(result)\n        self._add_guild_application_command(guild_id, cmd)\n        return cmd\n\n    async def edit_guild_command(\n        self, guild_id: int, command_id: int, new_command: ApplicationCommand\n    ) -> APIApplicationCommand:\n        assert self.application_id is not None\n        result = await self.http.edit_guild_command(\n            self.application_id, guild_id, command_id, new_command.to_dict()\n        )\n        cmd = application_command_factory(result)\n        self._add_guild_application_command(guild_id, cmd)\n        return cmd\n\n    async def delete_guild_command(self, guild_id: int, command_id: int) -> None:\n        assert self.application_id is not None\n        await self.http.delete_guild_command(self.application_id, guild_id, command_id)\n        self._remove_guild_application_command(guild_id, command_id)\n\n    async def bulk_overwrite_guild_commands(\n        self, guild_id: int, application_commands: list[ApplicationCommand]\n    ) -> list[APIApplicationCommand]:\n        assert self.application_id is not None\n        payload = [cmd.to_dict() for cmd in application_commands]\n        results = await self.http.bulk_upsert_guild_commands(self.application_id, guild_id, payload)\n        commands = [application_command_factory(data) for data in results]\n        self._guild_application_commands[guild_id] = {cmd.id: cmd for cmd in commands}\n        return commands\n\n    # Application command permissions\n\n    async def bulk_fetch_command_permissions(\n        self, guild_id: int\n    ) -> list[GuildApplicationCommandPermissions]:\n        assert self.application_id is not None\n        array = await self.http.get_guild_application_command_permissions(\n            self.application_id, guild_id\n        )\n        return [GuildApplicationCommandPermissions(state=self, data=obj) for obj in array]\n\n    async def fetch_command_permissions(\n        self, guild_id: int, command_id: int\n    ) -> GuildApplicationCommandPermissions:\n        assert self.application_id is not None\n        data = await self.http.get_application_command_permissions(\n            self.application_id, guild_id, command_id\n        )\n        return GuildApplicationCommandPermissions(state=self, data=data)", "n_imports_parsed": 8, "n_files_resolved": 2, "n_chars_extracted": 89178}, "tests/test_activity.py::57": {"resolved_imports": ["disnake/__init__.py", "disnake/activity.py"], "used_names": [], "enclosing_function": "test_text", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_embeds.py::192": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_attr_proxy", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_colour.py::32": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Colour", "pytest"], "enclosing_function": "test_to_rgb", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ui/test_decorators.py::64": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/button.py"], "used_names": ["Any", "assert_type", "pytest", "ui"], "enclosing_function": "test_cls", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 8, "n_files_resolved": 3, "n_chars_extracted": 1281}, "tests/ext/tasks/test_loops.py::21": {"resolved_imports": ["disnake/ext/commands/__init__.py", "disnake/ext/tasks/__init__.py"], "used_names": ["commands", "loop", "pytest"], "enclosing_function": "test_decorator", "extracted_code": "# Source: disnake/ext/tasks/__init__.py\ndef loop(\n    *,\n    seconds: float = ...,\n    minutes: float = ...,\n    hours: float = ...,\n    time: datetime.time | Sequence[datetime.time] = ...,\n    count: int | None = None,\n    reconnect: bool = True,\n    loop: asyncio.AbstractEventLoop = ...,\n) -> Callable[[LF], Loop[LF]]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, P], L_co], *_: P.args, **kwargs: P.kwargs\n) -> Callable[[LF], L_co]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, ...], L_co] = Loop[Any],\n    **kwargs: Any,\n) -> Callable[[LF], L_co]:\n    r\"\"\"A decorator that schedules a task in the background for you with\n    optional reconnect logic. The decorator returns a :class:`Loop`.\n\n    Parameters\n    ----------\n    cls: :class:`~collections.abc.Callable`\\[..., :class:`Loop`]\n        A callable (such as a :class:`Loop` subclass) returning an instance of a :class:`Loop`.\n        If provided, the other parameters described below do not apply.\n        Instead, this decorator will accept the same keyword arguments as the passed callable does.\n\n        .. versionadded:: 2.6\n\n    seconds: :class:`float`\n        The number of seconds between every iteration.\n    minutes: :class:`float`\n        The number of minutes between every iteration.\n    hours: :class:`float`\n        The number of hours between every iteration.\n    time: :class:`datetime.time` | :class:`~collections.abc.Sequence`\\[:class:`datetime.time`]\n        The exact times to run this loop at. Either a non-empty list or a single\n        value of :class:`datetime.time` should be passed. Timezones are supported.\n        If no timezone is given for the times, it is assumed to represent UTC time.\n\n        This cannot be used in conjunction with the relative time parameters.\n\n        .. note::\n\n            Duplicate times will be ignored, and only run once.\n\n        .. versionadded:: 2.0\n\n    count: :class:`int` | :data:`None`\n        The number of loops to do, :data:`None` if it should be an infinite loop.\n    reconnect: :class:`bool`\n        Whether to handle errors and restart the task using an exponential back-off algorithm\n        similar to the one used in :meth:`disnake.Client.connect`.\n    loop: :class:`asyncio.AbstractEventLoop`\n        The loop to use to register the task, if not given defaults to the current event loop\n        or creates a new one if there is none.\n\n    Raises\n    ------\n    ValueError\n        An invalid value for the ``count`` or ``time`` parameter was given.\n    TypeError\n        The function was not a coroutine, the ``cls`` parameter was not a callable\n        nor a subclass of ``Loop``, an invalid value for the ``time`` parameter was passed,\n        or the ``time`` parameter was passed in conjunction with relative time parameters.\n    \"\"\"\n    if not callable(cls):\n        msg = \"cls argument must be callable\"\n        raise TypeError(msg)\n\n    def decorator(func: LF) -> L_co:\n        if not iscoroutinefunction(func):\n            msg = \"The decorated function must be a coroutine function.\"\n            raise TypeError(msg)\n\n        return cast(\"type[L_co]\", cls)(func, **kwargs)\n\n    return decorator", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 3144}, "tests/test_onboarding.py::74": {"resolved_imports": ["disnake/__init__.py", "disnake/types/__init__.py", "disnake/types/onboarding.py"], "used_names": ["Onboarding", "onboarding"], "enclosing_function": "test_onboarding", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 3, "n_chars_extracted": 0}, "tests/ui/test_action_row.py::204": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow"], "enclosing_function": "test_walk_components", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/test_flags.py::116": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": ["pytest", "re"], "enclosing_function": "test_flag_value_or", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_object.py::29": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Object", "datetime", "timezone"], "enclosing_function": "test_created_at", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_onboarding.py::81": {"resolved_imports": ["disnake/__init__.py", "disnake/types/__init__.py", "disnake/types/onboarding.py"], "used_names": ["OnboardingPrompt", "OnboardingPromptType"], "enclosing_function": "test_onboarding_prompt", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 3, "n_chars_extracted": 0}, "tests/ext/commands/test_core.py::68": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": ["assert_type", "commands"], "enclosing_function": "_test_typing_cls", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_slash_core.py::26": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_parent", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ui/test_action_row.py::93": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow", "StringSelect", "TYPE_CHECKING"], "enclosing_function": "test_add_select", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/ext/tasks/test_loops.py::69": {"resolved_imports": ["disnake/ext/commands/__init__.py", "disnake/ext/tasks/__init__.py"], "used_names": ["Loop", "loop", "pytest"], "enclosing_function": "test_factory", "extracted_code": "# Source: disnake/ext/tasks/__init__.py\nclass Loop(Generic[LF]):\n    \"\"\"A background task helper that abstracts the loop and reconnection logic for you.\n\n    The main interface to create this is through :func:`loop`.\n    \"\"\"\n\n    def __init__(\n        self,\n        coro: LF,\n        *,\n        seconds: float = 0,\n        minutes: float = 0,\n        hours: float = 0,\n        time: datetime.time | Sequence[datetime.time] = MISSING,\n        count: int | None = None,\n        reconnect: bool = True,\n        loop: asyncio.AbstractEventLoop = MISSING,\n    ) -> None:\n        \"\"\".. note:\n        If you overwrite ``__init__`` arguments, make sure to redefine .clone too.\n        \"\"\"\n        self.coro: LF = coro\n        self.reconnect: bool = reconnect\n        self.loop: asyncio.AbstractEventLoop = loop\n        self.count: int | None = count\n        self._current_loop = 0\n        self._handle: SleepHandle = MISSING\n        self._task: asyncio.Task[None] = MISSING\n        self._injected: Any = None\n        self._valid_exception = (\n            OSError,\n            disnake.GatewayNotFound,\n            disnake.ConnectionClosed,\n            aiohttp.ClientError,\n            asyncio.TimeoutError,\n        )\n\n        self._before_loop = None\n        self._after_loop = None\n        self._is_being_cancelled = False\n        self._has_failed = False\n        self._stop_next_iteration = False\n\n        if self.count is not None and self.count <= 0:\n            msg = \"count must be greater than 0 or None.\"\n            raise ValueError(msg)\n\n        self.change_interval(seconds=seconds, minutes=minutes, hours=hours, time=time)\n        self._last_iteration_failed = False\n        self._last_iteration: datetime.datetime = MISSING\n        self._next_iteration = None\n\n        if not iscoroutinefunction(self.coro):\n            msg = f\"Expected coroutine function, not {type(self.coro).__name__!r}.\"\n            raise TypeError(msg)\n\n    async def _call_loop_function(self, name: str, *args: Any, **kwargs: Any) -> None:\n        coro = getattr(self, \"_\" + name)\n        if coro is None:\n            return\n\n        if self._injected is not None:\n            await coro(self._injected, *args, **kwargs)\n        else:\n            await coro(*args, **kwargs)\n\n    def _try_sleep_until(self, dt: datetime.datetime) -> asyncio.Future[bool]:\n        self._handle = SleepHandle(dt=dt, loop=self.loop)\n        return self._handle.wait()\n\n    async def _loop(self, *args: Any, **kwargs: Any) -> None:\n        backoff = ExponentialBackoff()\n        await self._call_loop_function(\"before_loop\")\n        self._last_iteration_failed = False\n        if self._time is not MISSING:\n            # the time index should be prepared every time the internal loop is started\n            self._prepare_time_index()\n            self._next_iteration = self._get_next_sleep_time()\n        else:\n            self._next_iteration = utcnow()\n        try:\n            await self._try_sleep_until(self._next_iteration)\n            while True:\n                if not self._last_iteration_failed:\n                    self._last_iteration = self._next_iteration\n                    self._next_iteration = self._get_next_sleep_time()\n                try:\n                    await self.coro(*args, **kwargs)\n                    self._last_iteration_failed = False\n                except self._valid_exception:\n                    self._last_iteration_failed = True\n                    if not self.reconnect:\n                        raise\n                    await asyncio.sleep(backoff.delay())\n                else:\n                    await self._try_sleep_until(self._next_iteration)\n\n                    if self._stop_next_iteration:\n                        return\n\n                    now = utcnow()\n                    if now > self._next_iteration:\n                        self._next_iteration = now\n                        if self._time is not MISSING:\n                            self._prepare_time_index(now)\n\n                    self._current_loop += 1\n                    if self._current_loop == self.count:\n                        break\n\n        except asyncio.CancelledError:\n            self._is_being_cancelled = True\n            raise\n        except Exception as exc:\n            self._has_failed = True\n            await self._call_loop_function(\"error\", exc)\n            raise\n        finally:\n            await self._call_loop_function(\"after_loop\")\n            self._handle.cancel()\n            self._is_being_cancelled = False\n            self._current_loop = 0\n            self._stop_next_iteration = False\n            self._has_failed = False\n\n    def __get__(self, obj: T, objtype: type[T]) -> Self:\n        if obj is None:\n            return self\n        clone = self.clone()\n        clone._injected = obj\n        setattr(obj, self.coro.__name__, clone)\n        return clone\n\n    def clone(self) -> Self:\n        instance = type(self)(\n            self.coro,\n            seconds=self._seconds,\n            hours=self._hours,\n            minutes=self._minutes,\n            time=self._time,\n            count=self.count,\n            reconnect=self.reconnect,\n            loop=self.loop,\n        )\n        instance._before_loop = self._before_loop\n        instance._after_loop = self._after_loop\n        instance._error = self._error\n        instance._injected = self._injected\n        return instance\n\n    @property\n    def seconds(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of seconds\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._seconds is not MISSING:\n            return self._seconds\n        return None\n\n    @property\n    def minutes(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of minutes\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._minutes is not MISSING:\n            return self._minutes\n        return None\n\n    @property\n    def hours(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of hours\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._hours is not MISSING:\n            return self._hours\n        return None\n\n    @property\n    def time(self) -> list[datetime.time] | None:\n        r\"\"\":class:`list`\\[:class:`datetime.time`] | :data:`None`: Read-only list for the exact times this loop runs at.\n        :data:`None` if relative times were passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._time is not MISSING:\n            return self._time.copy()\n        return None\n\n    @property\n    def current_loop(self) -> int:\n        \"\"\":class:`int`: The current iteration of the loop.\"\"\"\n        return self._current_loop\n\n    @property\n    def next_iteration(self) -> datetime.datetime | None:\n        \"\"\":class:`datetime.datetime` | :data:`None`: When the next iteration of the loop will occur.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self._task is MISSING or (self._task and self._task.done()) or self._stop_next_iteration:\n            return None\n        return self._next_iteration\n\n    async def __call__(self, *args: Any, **kwargs: Any) -> Any:\n        \"\"\"|coro|\n\n        Calls the internal callback that the task holds.\n\n        .. versionadded:: 1.6\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n        \"\"\"\n        if self._injected is not None:\n            args = (self._injected, *args)\n\n        return await self.coro(*args, **kwargs)\n\n    def start(self, *args: Any, **kwargs: Any) -> asyncio.Task[None]:\n        \"\"\"Starts the internal task in the event loop.\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n\n        Raises\n        ------\n        RuntimeError\n            A task has already been launched and is running.\n\n        Returns\n        -------\n        :class:`asyncio.Task`\n            The task that has been created.\n        \"\"\"\n        if self._task is not MISSING and not self._task.done():\n            msg = \"Task is already launched and is not completed.\"\n            raise RuntimeError(msg)\n\n        if self._injected is not None:\n            args = (self._injected, *args)\n\n        if self.loop is MISSING:\n            self.loop = disnake.utils.get_event_loop()\n\n        self._task = self.loop.create_task(self._loop(*args, **kwargs))\n        return self._task\n\n    def stop(self) -> None:\n        r\"\"\"Gracefully stops the task from running.\n\n        Unlike :meth:`cancel`\\, this allows the task to finish its\n        current iteration before gracefully exiting.\n\n        .. note::\n\n            If the internal function raises an error that can be\n            handled before finishing then it will retry until\n            it succeeds.\n\n            If this is undesirable, either remove the error handling\n            before stopping via :meth:`clear_exception_types` or\n            use :meth:`cancel` instead.\n\n        .. versionadded:: 1.2\n        \"\"\"\n        if self._task is not MISSING and not self._task.done():\n            self._stop_next_iteration = True\n\n    def _can_be_cancelled(self) -> bool:\n        return bool(not self._is_being_cancelled and self._task and not self._task.done())\n\n    def cancel(self) -> None:\n        \"\"\"Cancels the internal task, if it is running.\"\"\"\n        if self._can_be_cancelled():\n            self._task.cancel()\n\n    def restart(self, *args: Any, **kwargs: Any) -> None:\n        \"\"\"A convenience method to restart the internal task.\n\n        .. note::\n\n            Due to the way this function works, the task is not\n            returned like :meth:`start`.\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n        \"\"\"\n\n        def restart_when_over(fut: Any, *, args: Any = args, kwargs: Any = kwargs) -> None:\n            self._task.remove_done_callback(restart_when_over)\n            self.start(*args, **kwargs)\n\n        if self._can_be_cancelled():\n            self._task.add_done_callback(restart_when_over)\n            self._task.cancel()\n\n    def add_exception_type(self, *exceptions: type[BaseException]) -> None:\n        r\"\"\"Adds exception types to be handled during the reconnect logic.\n\n        By default the exception types handled are those handled by\n        :meth:`disnake.Client.connect`\\, which includes a lot of internet disconnection\n        errors.\n\n        This function is useful if you're interacting with a 3rd party library that\n        raises its own set of exceptions.\n\n        Parameters\n        ----------\n        *exceptions: :class:`type`\\[:class:`BaseException`]\n            An argument list of exception classes to handle.\n\n        Raises\n        ------\n        TypeError\n            An exception passed is either not a class or not inherited from :class:`BaseException`.\n        \"\"\"\n        for exc in exceptions:\n            if not inspect.isclass(exc):\n                msg = f\"{exc!r} must be a class.\"\n                raise TypeError(msg)\n            if not issubclass(exc, BaseException):\n                msg = f\"{exc!r} must inherit from BaseException.\"\n                raise TypeError(msg)\n\n        self._valid_exception = (*self._valid_exception, *exceptions)\n\n    def clear_exception_types(self) -> None:\n        \"\"\"Removes all exception types that are handled.\n\n        .. note::\n\n            This operation obviously cannot be undone!\n        \"\"\"\n        self._valid_exception = ()\n\n    def remove_exception_type(self, *exceptions: type[BaseException]) -> bool:\n        r\"\"\"Removes exception types from being handled during the reconnect logic.\n\n        Parameters\n        ----------\n        *exceptions: :class:`type`\\[:class:`BaseException`]\n            An argument list of exception classes to handle.\n\n        Returns\n        -------\n        :class:`bool`\n            Whether all exceptions were successfully removed.\n        \"\"\"\n        old_length = len(self._valid_exception)\n        self._valid_exception = tuple(x for x in self._valid_exception if x not in exceptions)\n        return len(self._valid_exception) == old_length - len(exceptions)\n\n    def get_task(self) -> asyncio.Task[None] | None:\n        \"\"\"Fetches the internal task or :data:`None` if there isn't one running.\n\n        :return type: :class:`asyncio.Task` | :data:`None`\n        \"\"\"\n        return self._task if self._task is not MISSING else None\n\n    def is_being_cancelled(self) -> bool:\n        \"\"\"Whether the task is being cancelled.\n\n        :return type: :class:`bool`\n        \"\"\"\n        return self._is_being_cancelled\n\n    def failed(self) -> bool:\n        \"\"\"Whether the internal task has failed.\n\n        .. versionadded:: 1.2\n\n        :return type: :class:`bool`\n        \"\"\"\n        return self._has_failed\n\n    def is_running(self) -> bool:\n        \"\"\"Check if the task is currently running.\n\n        .. versionadded:: 1.4\n\n        :return type: :class:`bool`\n        \"\"\"\n        return not bool(self._task.done()) if self._task is not MISSING else False\n\n    async def _error(self, *args: Any) -> None:\n        exception: Exception = args[-1]\n        print(\n            f\"Unhandled exception in internal background task {self.coro.__name__!r}.\",\n            file=sys.stderr,\n        )\n        traceback.print_exception(\n            type(exception), exception, exception.__traceback__, file=sys.stderr\n        )\n\n    def before_loop(self, coro: FT) -> FT:\n        \"\"\"A decorator that registers a coroutine function to be called before the loop starts running.\n\n        This is useful if you want to wait for some bot state before the loop starts,\n        such as :meth:`disnake.Client.wait_until_ready`.\n\n        The coroutine must take no arguments (except ``self`` in a class context).\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register before the loop runs.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._before_loop = coro\n        return coro\n\n    def after_loop(self, coro: FT) -> FT:\n        \"\"\"A decorator that register a coroutine function to be called after the loop finished running.\n\n        The coroutine must take no arguments (except ``self`` in a class context).\n\n        .. note::\n\n            This coroutine is called even during cancellation. If it is desirable\n            to tell apart whether something was cancelled or not, check to see\n            whether :meth:`is_being_cancelled` is ``True`` or not.\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register after the loop finishes.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._after_loop = coro\n        return coro\n\n    def error(self, coro: ET) -> ET:\n        \"\"\"A decorator that registers a coroutine function to be called if the task encounters an unhandled exception.\n\n        The coroutine must take only one argument the exception raised (except ``self`` in a class context).\n\n        By default this prints to :data:`sys.stderr` however it could be\n        overridden to have a different implementation.\n\n        .. versionadded:: 1.4\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register in the event of an unhandled exception.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._error = coro  # pyright: ignore[reportAttributeAccessIssue]\n        return coro\n\n    def _get_next_sleep_time(self) -> datetime.datetime:\n        if self._sleep is not MISSING:\n            return self._last_iteration + datetime.timedelta(seconds=self._sleep)\n\n        if self._time_index >= len(self._time):\n            self._time_index = 0\n            if self._current_loop == 0:\n                # if we're at the last index on the first iteration, we need to sleep until tomorrow\n                return datetime.datetime.combine(\n                    utcnow() + datetime.timedelta(days=1),\n                    self._time[0],\n                )\n\n        next_time = self._time[self._time_index]\n\n        if self._current_loop == 0:\n            self._time_index += 1\n            if next_time > utcnow().timetz():\n                return datetime.datetime.combine(utcnow(), next_time)\n            else:\n                return datetime.datetime.combine(\n                    utcnow() + datetime.timedelta(days=1),\n                    next_time,\n                )\n\n        next_date = self._last_iteration\n        if next_time < next_date.timetz():\n            next_date += datetime.timedelta(days=1)\n\n        self._time_index += 1\n        return datetime.datetime.combine(next_date, next_time)\n\n    def _prepare_time_index(self, now: datetime.datetime = MISSING) -> None:\n        # now kwarg should be a datetime.datetime representing the time \"now\"\n        # to calculate the next time index from\n\n        # pre-condition: self._time is set\n        time_now = (now if now is not MISSING else utcnow().replace(microsecond=0)).timetz()\n        for idx, time in enumerate(self._time):\n            if time >= time_now:\n                self._time_index = idx\n                break\n        else:\n            self._time_index = 0\n\n    def _get_time_parameter(\n        self,\n        time: datetime.time | Sequence[datetime.time],\n        *,\n        dt: type[datetime.time] = datetime.time,\n        utc: datetime.timezone = datetime.timezone.utc,\n    ) -> list[datetime.time]:\n        if isinstance(time, dt):\n            inner = time if time.tzinfo is not None else time.replace(tzinfo=utc)\n            return [inner]\n        if not isinstance(time, Sequence):\n            msg = f\"Expected datetime.time or a sequence of datetime.time for ``time``, received {type(time)!r} instead.\"\n            raise TypeError(msg)\n        if not time:\n            msg = \"time parameter must not be an empty sequence.\"\n            raise ValueError(msg)\n\n        ret: list[datetime.time] = []\n        for index, t in enumerate(time):\n            if not isinstance(t, dt):\n                msg = f\"Expected a sequence of {dt!r} for ``time``, received {type(t).__name__!r} at index {index} instead.\"\n                raise TypeError(msg)\n            ret.append(t if t.tzinfo is not None else t.replace(tzinfo=utc))\n\n        return sorted(set(ret))  # de-dupe and sort times\n\n    def change_interval(\n        self,\n        *,\n        seconds: float = 0,\n        minutes: float = 0,\n        hours: float = 0,\n        time: datetime.time | Sequence[datetime.time] = MISSING,\n    ) -> None:\n        r\"\"\"Changes the interval for the sleep time.\n\n        .. versionadded:: 1.2\n\n        Parameters\n        ----------\n        seconds: :class:`float`\n            The number of seconds between every iteration.\n        minutes: :class:`float`\n            The number of minutes between every iteration.\n        hours: :class:`float`\n            The number of hours between every iteration.\n        time: :class:`datetime.time` | :class:`~collections.abc.Sequence`\\[:class:`datetime.time`]\n            The exact times to run this loop at. Either a non-empty list or a single\n            value of :class:`datetime.time` should be passed.\n            This cannot be used in conjunction with the relative time parameters.\n\n            .. versionadded:: 2.0\n\n            .. note::\n\n                Duplicate times will be ignored, and only run once.\n\n        Raises\n        ------\n        ValueError\n            An invalid value was given.\n        TypeError\n            An invalid value for the ``time`` parameter was passed, or the\n            ``time`` parameter was passed in conjunction with relative time parameters.\n        \"\"\"\n        if time is MISSING:\n            seconds = seconds or 0\n            minutes = minutes or 0\n            hours = hours or 0\n            sleep = seconds + (minutes * 60.0) + (hours * 3600.0)\n            if sleep < 0:\n                msg = \"Total number of seconds cannot be less than zero.\"\n                raise ValueError(msg)\n\n            self._sleep = sleep\n            self._seconds = float(seconds)\n            self._hours = float(hours)\n            self._minutes = float(minutes)\n            self._time: list[datetime.time] = MISSING\n        else:\n            if any((seconds, minutes, hours)):\n                msg = \"Cannot mix explicit time with relative time\"\n                raise TypeError(msg)\n            self._time = self._get_time_parameter(time)\n            self._sleep = self._seconds = self._minutes = self._hours = MISSING\n\n        # `_last_iteration` can be missing if `change_interval` gets called in `before_loop` or\n        # before the event loop ticks after `start()`\n        if self.is_running() and self._last_iteration is not MISSING:\n            if self._time is not MISSING:\n                # prepare the next time index starting from after the last iteration\n                self._prepare_time_index(now=self._last_iteration)\n\n            self._next_iteration = self._get_next_sleep_time()\n            if not self._handle.done():\n                # the loop is sleeping, recalculate based on new interval\n                self._handle.recalculate(self._next_iteration)\n\ndef loop(\n    *,\n    seconds: float = ...,\n    minutes: float = ...,\n    hours: float = ...,\n    time: datetime.time | Sequence[datetime.time] = ...,\n    count: int | None = None,\n    reconnect: bool = True,\n    loop: asyncio.AbstractEventLoop = ...,\n) -> Callable[[LF], Loop[LF]]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, P], L_co], *_: P.args, **kwargs: P.kwargs\n) -> Callable[[LF], L_co]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, ...], L_co] = Loop[Any],\n    **kwargs: Any,\n) -> Callable[[LF], L_co]:\n    r\"\"\"A decorator that schedules a task in the background for you with\n    optional reconnect logic. The decorator returns a :class:`Loop`.\n\n    Parameters\n    ----------\n    cls: :class:`~collections.abc.Callable`\\[..., :class:`Loop`]\n        A callable (such as a :class:`Loop` subclass) returning an instance of a :class:`Loop`.\n        If provided, the other parameters described below do not apply.\n        Instead, this decorator will accept the same keyword arguments as the passed callable does.\n\n        .. versionadded:: 2.6\n\n    seconds: :class:`float`\n        The number of seconds between every iteration.\n    minutes: :class:`float`\n        The number of minutes between every iteration.\n    hours: :class:`float`\n        The number of hours between every iteration.\n    time: :class:`datetime.time` | :class:`~collections.abc.Sequence`\\[:class:`datetime.time`]\n        The exact times to run this loop at. Either a non-empty list or a single\n        value of :class:`datetime.time` should be passed. Timezones are supported.\n        If no timezone is given for the times, it is assumed to represent UTC time.\n\n        This cannot be used in conjunction with the relative time parameters.\n\n        .. note::\n\n            Duplicate times will be ignored, and only run once.\n\n        .. versionadded:: 2.0\n\n    count: :class:`int` | :data:`None`\n        The number of loops to do, :data:`None` if it should be an infinite loop.\n    reconnect: :class:`bool`\n        Whether to handle errors and restart the task using an exponential back-off algorithm\n        similar to the one used in :meth:`disnake.Client.connect`.\n    loop: :class:`asyncio.AbstractEventLoop`\n        The loop to use to register the task, if not given defaults to the current event loop\n        or creates a new one if there is none.\n\n    Raises\n    ------\n    ValueError\n        An invalid value for the ``count`` or ``time`` parameter was given.\n    TypeError\n        The function was not a coroutine, the ``cls`` parameter was not a callable\n        nor a subclass of ``Loop``, an invalid value for the ``time`` parameter was passed,\n        or the ``time`` parameter was passed in conjunction with relative time parameters.\n    \"\"\"\n    if not callable(cls):\n        msg = \"cls argument must be callable\"\n        raise TypeError(msg)\n\n    def decorator(func: LF) -> L_co:\n        if not iscoroutinefunction(func):\n            msg = \"The decorated function must be a coroutine function.\"\n            raise TypeError(msg)\n\n        return cast(\"type[L_co]\", cls)(func, **kwargs)\n\n    return decorator", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 25461}, "tests/test_embeds.py::72": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_len", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ui/test_decorators.py::62": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/button.py"], "used_names": ["Any", "assert_type", "pytest", "ui"], "enclosing_function": "test_cls", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 8, "n_files_resolved": 3, "n_chars_extracted": 1281}, "tests/ui/test_decorators.py::43": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/button.py"], "used_names": ["Any", "assert_type", "ui"], "enclosing_function": "test_default", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 8, "n_files_resolved": 3, "n_chars_extracted": 1281}, "tests/ext/commands/test_base_core.py::109": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["commands", "disnake"], "enclosing_function": "test_contexts_guildcommandinteraction", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/ui/test_action_row.py::134": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow"], "enclosing_function": "test_dunder", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/interactions/test_base.py::93": {"resolved_imports": ["disnake/__init__.py", "disnake/state.py"], "used_names": ["MISSING", "disnake", "pytest"], "enclosing_function": "test_defer", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 8, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/ext/commands/test_base_core.py::124": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["commands"], "enclosing_function": "test_default", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_message.py::57": {"resolved_imports": ["disnake/__init__.py", "disnake/message.py"], "used_names": ["disnake", "message", "pytest"], "enclosing_function": "test_convert_emoji_reaction__object", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/ui/test_select.py::47": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py"], "used_names": ["disnake", "mock", "pytest", "ui"], "enclosing_function": "test_mentionable", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/test_mentions.py::101": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["AllowedMentions", "Object", "mock"], "enclosing_function": "test_from_message", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/tasks/test_loops.py::30": {"resolved_imports": ["disnake/ext/commands/__init__.py", "disnake/ext/tasks/__init__.py"], "used_names": ["Loop", "datetime", "loop", "pytest"], "enclosing_function": "test_mixing_time", "extracted_code": "# Source: disnake/ext/tasks/__init__.py\nclass Loop(Generic[LF]):\n    \"\"\"A background task helper that abstracts the loop and reconnection logic for you.\n\n    The main interface to create this is through :func:`loop`.\n    \"\"\"\n\n    def __init__(\n        self,\n        coro: LF,\n        *,\n        seconds: float = 0,\n        minutes: float = 0,\n        hours: float = 0,\n        time: datetime.time | Sequence[datetime.time] = MISSING,\n        count: int | None = None,\n        reconnect: bool = True,\n        loop: asyncio.AbstractEventLoop = MISSING,\n    ) -> None:\n        \"\"\".. note:\n        If you overwrite ``__init__`` arguments, make sure to redefine .clone too.\n        \"\"\"\n        self.coro: LF = coro\n        self.reconnect: bool = reconnect\n        self.loop: asyncio.AbstractEventLoop = loop\n        self.count: int | None = count\n        self._current_loop = 0\n        self._handle: SleepHandle = MISSING\n        self._task: asyncio.Task[None] = MISSING\n        self._injected: Any = None\n        self._valid_exception = (\n            OSError,\n            disnake.GatewayNotFound,\n            disnake.ConnectionClosed,\n            aiohttp.ClientError,\n            asyncio.TimeoutError,\n        )\n\n        self._before_loop = None\n        self._after_loop = None\n        self._is_being_cancelled = False\n        self._has_failed = False\n        self._stop_next_iteration = False\n\n        if self.count is not None and self.count <= 0:\n            msg = \"count must be greater than 0 or None.\"\n            raise ValueError(msg)\n\n        self.change_interval(seconds=seconds, minutes=minutes, hours=hours, time=time)\n        self._last_iteration_failed = False\n        self._last_iteration: datetime.datetime = MISSING\n        self._next_iteration = None\n\n        if not iscoroutinefunction(self.coro):\n            msg = f\"Expected coroutine function, not {type(self.coro).__name__!r}.\"\n            raise TypeError(msg)\n\n    async def _call_loop_function(self, name: str, *args: Any, **kwargs: Any) -> None:\n        coro = getattr(self, \"_\" + name)\n        if coro is None:\n            return\n\n        if self._injected is not None:\n            await coro(self._injected, *args, **kwargs)\n        else:\n            await coro(*args, **kwargs)\n\n    def _try_sleep_until(self, dt: datetime.datetime) -> asyncio.Future[bool]:\n        self._handle = SleepHandle(dt=dt, loop=self.loop)\n        return self._handle.wait()\n\n    async def _loop(self, *args: Any, **kwargs: Any) -> None:\n        backoff = ExponentialBackoff()\n        await self._call_loop_function(\"before_loop\")\n        self._last_iteration_failed = False\n        if self._time is not MISSING:\n            # the time index should be prepared every time the internal loop is started\n            self._prepare_time_index()\n            self._next_iteration = self._get_next_sleep_time()\n        else:\n            self._next_iteration = utcnow()\n        try:\n            await self._try_sleep_until(self._next_iteration)\n            while True:\n                if not self._last_iteration_failed:\n                    self._last_iteration = self._next_iteration\n                    self._next_iteration = self._get_next_sleep_time()\n                try:\n                    await self.coro(*args, **kwargs)\n                    self._last_iteration_failed = False\n                except self._valid_exception:\n                    self._last_iteration_failed = True\n                    if not self.reconnect:\n                        raise\n                    await asyncio.sleep(backoff.delay())\n                else:\n                    await self._try_sleep_until(self._next_iteration)\n\n                    if self._stop_next_iteration:\n                        return\n\n                    now = utcnow()\n                    if now > self._next_iteration:\n                        self._next_iteration = now\n                        if self._time is not MISSING:\n                            self._prepare_time_index(now)\n\n                    self._current_loop += 1\n                    if self._current_loop == self.count:\n                        break\n\n        except asyncio.CancelledError:\n            self._is_being_cancelled = True\n            raise\n        except Exception as exc:\n            self._has_failed = True\n            await self._call_loop_function(\"error\", exc)\n            raise\n        finally:\n            await self._call_loop_function(\"after_loop\")\n            self._handle.cancel()\n            self._is_being_cancelled = False\n            self._current_loop = 0\n            self._stop_next_iteration = False\n            self._has_failed = False\n\n    def __get__(self, obj: T, objtype: type[T]) -> Self:\n        if obj is None:\n            return self\n        clone = self.clone()\n        clone._injected = obj\n        setattr(obj, self.coro.__name__, clone)\n        return clone\n\n    def clone(self) -> Self:\n        instance = type(self)(\n            self.coro,\n            seconds=self._seconds,\n            hours=self._hours,\n            minutes=self._minutes,\n            time=self._time,\n            count=self.count,\n            reconnect=self.reconnect,\n            loop=self.loop,\n        )\n        instance._before_loop = self._before_loop\n        instance._after_loop = self._after_loop\n        instance._error = self._error\n        instance._injected = self._injected\n        return instance\n\n    @property\n    def seconds(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of seconds\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._seconds is not MISSING:\n            return self._seconds\n        return None\n\n    @property\n    def minutes(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of minutes\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._minutes is not MISSING:\n            return self._minutes\n        return None\n\n    @property\n    def hours(self) -> float | None:\n        \"\"\":class:`float` | :data:`None`: Read-only value for the number of hours\n        between each iteration. :data:`None` if an explicit ``time`` value was passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._hours is not MISSING:\n            return self._hours\n        return None\n\n    @property\n    def time(self) -> list[datetime.time] | None:\n        r\"\"\":class:`list`\\[:class:`datetime.time`] | :data:`None`: Read-only list for the exact times this loop runs at.\n        :data:`None` if relative times were passed instead.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        if self._time is not MISSING:\n            return self._time.copy()\n        return None\n\n    @property\n    def current_loop(self) -> int:\n        \"\"\":class:`int`: The current iteration of the loop.\"\"\"\n        return self._current_loop\n\n    @property\n    def next_iteration(self) -> datetime.datetime | None:\n        \"\"\":class:`datetime.datetime` | :data:`None`: When the next iteration of the loop will occur.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self._task is MISSING or (self._task and self._task.done()) or self._stop_next_iteration:\n            return None\n        return self._next_iteration\n\n    async def __call__(self, *args: Any, **kwargs: Any) -> Any:\n        \"\"\"|coro|\n\n        Calls the internal callback that the task holds.\n\n        .. versionadded:: 1.6\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n        \"\"\"\n        if self._injected is not None:\n            args = (self._injected, *args)\n\n        return await self.coro(*args, **kwargs)\n\n    def start(self, *args: Any, **kwargs: Any) -> asyncio.Task[None]:\n        \"\"\"Starts the internal task in the event loop.\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n\n        Raises\n        ------\n        RuntimeError\n            A task has already been launched and is running.\n\n        Returns\n        -------\n        :class:`asyncio.Task`\n            The task that has been created.\n        \"\"\"\n        if self._task is not MISSING and not self._task.done():\n            msg = \"Task is already launched and is not completed.\"\n            raise RuntimeError(msg)\n\n        if self._injected is not None:\n            args = (self._injected, *args)\n\n        if self.loop is MISSING:\n            self.loop = disnake.utils.get_event_loop()\n\n        self._task = self.loop.create_task(self._loop(*args, **kwargs))\n        return self._task\n\n    def stop(self) -> None:\n        r\"\"\"Gracefully stops the task from running.\n\n        Unlike :meth:`cancel`\\, this allows the task to finish its\n        current iteration before gracefully exiting.\n\n        .. note::\n\n            If the internal function raises an error that can be\n            handled before finishing then it will retry until\n            it succeeds.\n\n            If this is undesirable, either remove the error handling\n            before stopping via :meth:`clear_exception_types` or\n            use :meth:`cancel` instead.\n\n        .. versionadded:: 1.2\n        \"\"\"\n        if self._task is not MISSING and not self._task.done():\n            self._stop_next_iteration = True\n\n    def _can_be_cancelled(self) -> bool:\n        return bool(not self._is_being_cancelled and self._task and not self._task.done())\n\n    def cancel(self) -> None:\n        \"\"\"Cancels the internal task, if it is running.\"\"\"\n        if self._can_be_cancelled():\n            self._task.cancel()\n\n    def restart(self, *args: Any, **kwargs: Any) -> None:\n        \"\"\"A convenience method to restart the internal task.\n\n        .. note::\n\n            Due to the way this function works, the task is not\n            returned like :meth:`start`.\n\n        Parameters\n        ----------\n        *args\n            The arguments to use.\n        **kwargs\n            The keyword arguments to use.\n        \"\"\"\n\n        def restart_when_over(fut: Any, *, args: Any = args, kwargs: Any = kwargs) -> None:\n            self._task.remove_done_callback(restart_when_over)\n            self.start(*args, **kwargs)\n\n        if self._can_be_cancelled():\n            self._task.add_done_callback(restart_when_over)\n            self._task.cancel()\n\n    def add_exception_type(self, *exceptions: type[BaseException]) -> None:\n        r\"\"\"Adds exception types to be handled during the reconnect logic.\n\n        By default the exception types handled are those handled by\n        :meth:`disnake.Client.connect`\\, which includes a lot of internet disconnection\n        errors.\n\n        This function is useful if you're interacting with a 3rd party library that\n        raises its own set of exceptions.\n\n        Parameters\n        ----------\n        *exceptions: :class:`type`\\[:class:`BaseException`]\n            An argument list of exception classes to handle.\n\n        Raises\n        ------\n        TypeError\n            An exception passed is either not a class or not inherited from :class:`BaseException`.\n        \"\"\"\n        for exc in exceptions:\n            if not inspect.isclass(exc):\n                msg = f\"{exc!r} must be a class.\"\n                raise TypeError(msg)\n            if not issubclass(exc, BaseException):\n                msg = f\"{exc!r} must inherit from BaseException.\"\n                raise TypeError(msg)\n\n        self._valid_exception = (*self._valid_exception, *exceptions)\n\n    def clear_exception_types(self) -> None:\n        \"\"\"Removes all exception types that are handled.\n\n        .. note::\n\n            This operation obviously cannot be undone!\n        \"\"\"\n        self._valid_exception = ()\n\n    def remove_exception_type(self, *exceptions: type[BaseException]) -> bool:\n        r\"\"\"Removes exception types from being handled during the reconnect logic.\n\n        Parameters\n        ----------\n        *exceptions: :class:`type`\\[:class:`BaseException`]\n            An argument list of exception classes to handle.\n\n        Returns\n        -------\n        :class:`bool`\n            Whether all exceptions were successfully removed.\n        \"\"\"\n        old_length = len(self._valid_exception)\n        self._valid_exception = tuple(x for x in self._valid_exception if x not in exceptions)\n        return len(self._valid_exception) == old_length - len(exceptions)\n\n    def get_task(self) -> asyncio.Task[None] | None:\n        \"\"\"Fetches the internal task or :data:`None` if there isn't one running.\n\n        :return type: :class:`asyncio.Task` | :data:`None`\n        \"\"\"\n        return self._task if self._task is not MISSING else None\n\n    def is_being_cancelled(self) -> bool:\n        \"\"\"Whether the task is being cancelled.\n\n        :return type: :class:`bool`\n        \"\"\"\n        return self._is_being_cancelled\n\n    def failed(self) -> bool:\n        \"\"\"Whether the internal task has failed.\n\n        .. versionadded:: 1.2\n\n        :return type: :class:`bool`\n        \"\"\"\n        return self._has_failed\n\n    def is_running(self) -> bool:\n        \"\"\"Check if the task is currently running.\n\n        .. versionadded:: 1.4\n\n        :return type: :class:`bool`\n        \"\"\"\n        return not bool(self._task.done()) if self._task is not MISSING else False\n\n    async def _error(self, *args: Any) -> None:\n        exception: Exception = args[-1]\n        print(\n            f\"Unhandled exception in internal background task {self.coro.__name__!r}.\",\n            file=sys.stderr,\n        )\n        traceback.print_exception(\n            type(exception), exception, exception.__traceback__, file=sys.stderr\n        )\n\n    def before_loop(self, coro: FT) -> FT:\n        \"\"\"A decorator that registers a coroutine function to be called before the loop starts running.\n\n        This is useful if you want to wait for some bot state before the loop starts,\n        such as :meth:`disnake.Client.wait_until_ready`.\n\n        The coroutine must take no arguments (except ``self`` in a class context).\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register before the loop runs.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._before_loop = coro\n        return coro\n\n    def after_loop(self, coro: FT) -> FT:\n        \"\"\"A decorator that register a coroutine function to be called after the loop finished running.\n\n        The coroutine must take no arguments (except ``self`` in a class context).\n\n        .. note::\n\n            This coroutine is called even during cancellation. If it is desirable\n            to tell apart whether something was cancelled or not, check to see\n            whether :meth:`is_being_cancelled` is ``True`` or not.\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register after the loop finishes.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._after_loop = coro\n        return coro\n\n    def error(self, coro: ET) -> ET:\n        \"\"\"A decorator that registers a coroutine function to be called if the task encounters an unhandled exception.\n\n        The coroutine must take only one argument the exception raised (except ``self`` in a class context).\n\n        By default this prints to :data:`sys.stderr` however it could be\n        overridden to have a different implementation.\n\n        .. versionadded:: 1.4\n\n        Parameters\n        ----------\n        coro: :ref:`coroutine function <coroutine>`\n            The coroutine function to register in the event of an unhandled exception.\n\n        Raises\n        ------\n        TypeError\n            The function was not a coroutine function.\n        \"\"\"\n        if not iscoroutinefunction(coro):\n            msg = f\"Expected coroutine function, received {coro.__class__.__name__!r}.\"\n            raise TypeError(msg)\n\n        self._error = coro  # pyright: ignore[reportAttributeAccessIssue]\n        return coro\n\n    def _get_next_sleep_time(self) -> datetime.datetime:\n        if self._sleep is not MISSING:\n            return self._last_iteration + datetime.timedelta(seconds=self._sleep)\n\n        if self._time_index >= len(self._time):\n            self._time_index = 0\n            if self._current_loop == 0:\n                # if we're at the last index on the first iteration, we need to sleep until tomorrow\n                return datetime.datetime.combine(\n                    utcnow() + datetime.timedelta(days=1),\n                    self._time[0],\n                )\n\n        next_time = self._time[self._time_index]\n\n        if self._current_loop == 0:\n            self._time_index += 1\n            if next_time > utcnow().timetz():\n                return datetime.datetime.combine(utcnow(), next_time)\n            else:\n                return datetime.datetime.combine(\n                    utcnow() + datetime.timedelta(days=1),\n                    next_time,\n                )\n\n        next_date = self._last_iteration\n        if next_time < next_date.timetz():\n            next_date += datetime.timedelta(days=1)\n\n        self._time_index += 1\n        return datetime.datetime.combine(next_date, next_time)\n\n    def _prepare_time_index(self, now: datetime.datetime = MISSING) -> None:\n        # now kwarg should be a datetime.datetime representing the time \"now\"\n        # to calculate the next time index from\n\n        # pre-condition: self._time is set\n        time_now = (now if now is not MISSING else utcnow().replace(microsecond=0)).timetz()\n        for idx, time in enumerate(self._time):\n            if time >= time_now:\n                self._time_index = idx\n                break\n        else:\n            self._time_index = 0\n\n    def _get_time_parameter(\n        self,\n        time: datetime.time | Sequence[datetime.time],\n        *,\n        dt: type[datetime.time] = datetime.time,\n        utc: datetime.timezone = datetime.timezone.utc,\n    ) -> list[datetime.time]:\n        if isinstance(time, dt):\n            inner = time if time.tzinfo is not None else time.replace(tzinfo=utc)\n            return [inner]\n        if not isinstance(time, Sequence):\n            msg = f\"Expected datetime.time or a sequence of datetime.time for ``time``, received {type(time)!r} instead.\"\n            raise TypeError(msg)\n        if not time:\n            msg = \"time parameter must not be an empty sequence.\"\n            raise ValueError(msg)\n\n        ret: list[datetime.time] = []\n        for index, t in enumerate(time):\n            if not isinstance(t, dt):\n                msg = f\"Expected a sequence of {dt!r} for ``time``, received {type(t).__name__!r} at index {index} instead.\"\n                raise TypeError(msg)\n            ret.append(t if t.tzinfo is not None else t.replace(tzinfo=utc))\n\n        return sorted(set(ret))  # de-dupe and sort times\n\n    def change_interval(\n        self,\n        *,\n        seconds: float = 0,\n        minutes: float = 0,\n        hours: float = 0,\n        time: datetime.time | Sequence[datetime.time] = MISSING,\n    ) -> None:\n        r\"\"\"Changes the interval for the sleep time.\n\n        .. versionadded:: 1.2\n\n        Parameters\n        ----------\n        seconds: :class:`float`\n            The number of seconds between every iteration.\n        minutes: :class:`float`\n            The number of minutes between every iteration.\n        hours: :class:`float`\n            The number of hours between every iteration.\n        time: :class:`datetime.time` | :class:`~collections.abc.Sequence`\\[:class:`datetime.time`]\n            The exact times to run this loop at. Either a non-empty list or a single\n            value of :class:`datetime.time` should be passed.\n            This cannot be used in conjunction with the relative time parameters.\n\n            .. versionadded:: 2.0\n\n            .. note::\n\n                Duplicate times will be ignored, and only run once.\n\n        Raises\n        ------\n        ValueError\n            An invalid value was given.\n        TypeError\n            An invalid value for the ``time`` parameter was passed, or the\n            ``time`` parameter was passed in conjunction with relative time parameters.\n        \"\"\"\n        if time is MISSING:\n            seconds = seconds or 0\n            minutes = minutes or 0\n            hours = hours or 0\n            sleep = seconds + (minutes * 60.0) + (hours * 3600.0)\n            if sleep < 0:\n                msg = \"Total number of seconds cannot be less than zero.\"\n                raise ValueError(msg)\n\n            self._sleep = sleep\n            self._seconds = float(seconds)\n            self._hours = float(hours)\n            self._minutes = float(minutes)\n            self._time: list[datetime.time] = MISSING\n        else:\n            if any((seconds, minutes, hours)):\n                msg = \"Cannot mix explicit time with relative time\"\n                raise TypeError(msg)\n            self._time = self._get_time_parameter(time)\n            self._sleep = self._seconds = self._minutes = self._hours = MISSING\n\n        # `_last_iteration` can be missing if `change_interval` gets called in `before_loop` or\n        # before the event loop ticks after `start()`\n        if self.is_running() and self._last_iteration is not MISSING:\n            if self._time is not MISSING:\n                # prepare the next time index starting from after the last iteration\n                self._prepare_time_index(now=self._last_iteration)\n\n            self._next_iteration = self._get_next_sleep_time()\n            if not self._handle.done():\n                # the loop is sleeping, recalculate based on new interval\n                self._handle.recalculate(self._next_iteration)\n\ndef loop(\n    *,\n    seconds: float = ...,\n    minutes: float = ...,\n    hours: float = ...,\n    time: datetime.time | Sequence[datetime.time] = ...,\n    count: int | None = None,\n    reconnect: bool = True,\n    loop: asyncio.AbstractEventLoop = ...,\n) -> Callable[[LF], Loop[LF]]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, P], L_co], *_: P.args, **kwargs: P.kwargs\n) -> Callable[[LF], L_co]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, ...], L_co] = Loop[Any],\n    **kwargs: Any,\n) -> Callable[[LF], L_co]:\n    r\"\"\"A decorator that schedules a task in the background for you with\n    optional reconnect logic. The decorator returns a :class:`Loop`.\n\n    Parameters\n    ----------\n    cls: :class:`~collections.abc.Callable`\\[..., :class:`Loop`]\n        A callable (such as a :class:`Loop` subclass) returning an instance of a :class:`Loop`.\n        If provided, the other parameters described below do not apply.\n        Instead, this decorator will accept the same keyword arguments as the passed callable does.\n\n        .. versionadded:: 2.6\n\n    seconds: :class:`float`\n        The number of seconds between every iteration.\n    minutes: :class:`float`\n        The number of minutes between every iteration.\n    hours: :class:`float`\n        The number of hours between every iteration.\n    time: :class:`datetime.time` | :class:`~collections.abc.Sequence`\\[:class:`datetime.time`]\n        The exact times to run this loop at. Either a non-empty list or a single\n        value of :class:`datetime.time` should be passed. Timezones are supported.\n        If no timezone is given for the times, it is assumed to represent UTC time.\n\n        This cannot be used in conjunction with the relative time parameters.\n\n        .. note::\n\n            Duplicate times will be ignored, and only run once.\n\n        .. versionadded:: 2.0\n\n    count: :class:`int` | :data:`None`\n        The number of loops to do, :data:`None` if it should be an infinite loop.\n    reconnect: :class:`bool`\n        Whether to handle errors and restart the task using an exponential back-off algorithm\n        similar to the one used in :meth:`disnake.Client.connect`.\n    loop: :class:`asyncio.AbstractEventLoop`\n        The loop to use to register the task, if not given defaults to the current event loop\n        or creates a new one if there is none.\n\n    Raises\n    ------\n    ValueError\n        An invalid value for the ``count`` or ``time`` parameter was given.\n    TypeError\n        The function was not a coroutine, the ``cls`` parameter was not a callable\n        nor a subclass of ``Loop``, an invalid value for the ``time`` parameter was passed,\n        or the ``time`` parameter was passed in conjunction with relative time parameters.\n    \"\"\"\n    if not callable(cls):\n        msg = \"cls argument must be callable\"\n        raise TypeError(msg)\n\n    def decorator(func: LF) -> L_co:\n        if not iscoroutinefunction(func):\n            msg = \"The decorated function must be a coroutine function.\"\n            raise TypeError(msg)\n\n        return cast(\"type[L_co]\", cls)(func, **kwargs)\n\n    return decorator", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 25461}, "tests/ui/test_action_row.py::161": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow", "disnake", "mock"], "enclosing_function": "test_rows_from_message", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 357}, "tests/test_mentions.py::98": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["AllowedMentions", "Object", "mock"], "enclosing_function": "test_from_message", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_mentions.py::80": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["AllowedMentions", "Object", "pytest"], "enclosing_function": "test_merge", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_utils.py::75": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["datetime", "timezone", "utils"], "enclosing_function": "test_parse_time", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_slash_core.py::47": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_parents", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ui/test_action_row.py::203": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow"], "enclosing_function": "test_walk_components", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/test_events.py::48": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Event", "disnake", "pytest"], "enclosing_function": "test_wait_for", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/ext/commands/test_base_core.py::138": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["commands", "disnake"], "enclosing_function": "test_annotation_override", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/test_colour.py::11": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Colour", "pytest"], "enclosing_function": "test_init", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/interactions/test_base.py::127": {"resolved_imports": ["disnake/__init__.py", "disnake/state.py"], "used_names": ["disnake", "pytest"], "enclosing_function": "test_defer_invalid_parent", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 8, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/interactions/test_base.py::169": {"resolved_imports": ["disnake/__init__.py", "disnake/state.py"], "used_names": ["disnake"], "enclosing_function": "test_init_member", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 8, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/ext/commands/test_base_core.py::48": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Permissions", "commands", "pytest"], "enclosing_function": "test_decorator_overwrite", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_message.py::21": {"resolved_imports": ["disnake/__init__.py", "disnake/message.py"], "used_names": ["message", "pytest"], "enclosing_function": "test_convert_emoji_reaction__standard", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_activity.py::45": {"resolved_imports": ["disnake/__init__.py", "disnake/activity.py"], "used_names": [], "enclosing_function": "test_none", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ext/commands/test_slash_core.py::27": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_parent", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_object.py::21": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Object"], "enclosing_function": "test_compare", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_base_core.py::125": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["commands"], "enclosing_function": "test_default", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_permissions.py::218": {"resolved_imports": ["disnake/permissions.py"], "used_names": ["PermissionOverwrite"], "enclosing_function": "test_equality", "extracted_code": "# Source: disnake/permissions.py\nclass PermissionOverwrite:\n    r\"\"\"A type that is used to represent a channel specific permission.\n\n    Unlike a regular :class:`Permissions`\\, the default value of a\n    permission is equivalent to :data:`None` and not ``False``. Setting\n    a value to ``False`` is **explicitly** denying that permission,\n    while setting a value to ``True`` is **explicitly** allowing\n    that permission.\n\n    The values supported by this are the same as :class:`Permissions`\n    with the added possibility of it being set to :data:`None`.\n\n    .. collapse:: operations\n\n        .. describe:: x == y\n\n            Checks if two overwrites are equal.\n        .. describe:: x != y\n\n            Checks if two overwrites are not equal.\n        .. describe:: iter(x)\n\n           Returns an iterator of ``(perm, value)`` pairs. This allows it\n           to be, for example, constructed as a dict or a list of pairs.\n           Note that aliases are not shown.\n\n    Parameters\n    ----------\n    **kwargs\n        Set the value of permissions by their name.\n    \"\"\"\n\n    __slots__ = (\"_values\",)\n\n    # n. b. this typechecking block must be first and separate from the secondary one, due to codemodding\n    if TYPE_CHECKING:\n        add_reactions: bool | None\n        administrator: bool | None\n        attach_files: bool | None\n        ban_members: bool | None\n        bypass_slowmode: bool | None\n        change_nickname: bool | None\n        connect: bool | None\n        create_events: bool | None\n        create_forum_threads: bool | None\n        create_guild_expressions: bool | None\n        create_instant_invite: bool | None\n        create_private_threads: bool | None\n        create_public_threads: bool | None\n        deafen_members: bool | None\n        embed_links: bool | None\n        external_emojis: bool | None\n        external_stickers: bool | None\n        kick_members: bool | None\n        manage_channels: bool | None\n        manage_emojis: bool | None\n        manage_emojis_and_stickers: bool | None\n        manage_events: bool | None\n        manage_guild: bool | None\n        manage_guild_expressions: bool | None\n        manage_messages: bool | None\n        manage_nicknames: bool | None\n        manage_permissions: bool | None\n        manage_roles: bool | None\n        manage_threads: bool | None\n        manage_webhooks: bool | None\n        mention_everyone: bool | None\n        moderate_members: bool | None\n        move_members: bool | None\n        mute_members: bool | None\n        pin_messages: bool | None\n        priority_speaker: bool | None\n        read_message_history: bool | None\n        read_messages: bool | None\n        request_to_speak: bool | None\n        send_messages: bool | None\n        send_messages_in_threads: bool | None\n        send_polls: bool | None\n        send_tts_messages: bool | None\n        send_voice_messages: bool | None\n        speak: bool | None\n        start_embedded_activities: bool | None\n        stream: bool | None\n        use_application_commands: bool | None\n        use_embedded_activities: bool | None\n        use_external_apps: bool | None\n        use_external_emojis: bool | None\n        use_external_sounds: bool | None\n        use_external_stickers: bool | None\n        use_slash_commands: bool | None\n        use_soundboard: bool | None\n        use_voice_activation: bool | None\n        view_audit_log: bool | None\n        view_channel: bool | None\n        view_creator_monetization_analytics: bool | None\n        view_guild_insights: bool | None\n\n    if TYPE_CHECKING:\n        VALID_NAMES: ClassVar[set[str]]\n        PURE_FLAGS: ClassVar[set[str]]\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        *,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def __init__(self, **kwargs: bool | None) -> None:\n        self._values: dict[str, bool | None] = {}\n\n        for key, value in kwargs.items():\n            if key not in self.VALID_NAMES:\n                msg = f\"{key!r} is not a valid permission name.\"\n                raise ValueError(msg)\n\n            setattr(self, key, value)\n\n    def __eq__(self, other: object) -> bool:\n        return isinstance(other, PermissionOverwrite) and self._values == other._values\n\n    def _set(self, key: str, value: bool | None) -> None:\n        if value not in (True, None, False):\n            msg = f\"Expected bool or NoneType, received {value.__class__.__name__}\"\n            raise TypeError(msg)\n\n        if value is None:\n            self._values.pop(key, None)\n        else:\n            self._values[key] = value\n\n    def pair(self) -> tuple[Permissions, Permissions]:\n        r\"\"\":class:`tuple`\\[:class:`Permissions`, :class:`Permissions`]: Returns the (allow, deny) pair from this overwrite.\"\"\"\n        allow = Permissions.none()\n        deny = Permissions.none()\n\n        for key, value in self._values.items():\n            if value is True:\n                setattr(allow, key, True)\n            elif value is False:\n                setattr(deny, key, True)\n\n        return allow, deny\n\n    @classmethod\n    def from_pair(cls, allow: Permissions, deny: Permissions) -> Self:\n        \"\"\"Creates an overwrite from an allow/deny pair of :class:`Permissions`.\"\"\"\n        ret = cls()\n        for key, value in allow:\n            if value is True:\n                setattr(ret, key, True)\n\n        for key, value in deny:\n            if value is True:\n                setattr(ret, key, False)\n\n        return ret\n\n    def is_empty(self) -> bool:\n        \"\"\"Checks if the permission overwrite is currently empty.\n\n        An empty permission overwrite is one that has no overwrites set\n        to ``True`` or ``False``.\n\n        Returns\n        -------\n        :class:`bool`\n            Indicates if the overwrite is empty.\n        \"\"\"\n        return len(self._values) == 0\n\n    @overload\n    @_generated\n    def update(\n        self,\n        *,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def update(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def update(self, **kwargs: bool | None) -> None:\n        \"\"\"Bulk updates this permission overwrite object.\n\n        Allows you to set multiple attributes by using keyword\n        arguments. The names must be equivalent to the properties\n        listed. Extraneous key/value pairs will be silently ignored.\n\n        Parameters\n        ----------\n        **kwargs\n            A list of key/value pairs to bulk update with.\n        \"\"\"\n        for key, value in kwargs.items():\n            if key not in self.VALID_NAMES:\n                continue\n\n            setattr(self, key, value)\n\n    def __iter__(self) -> Iterator[tuple[str, bool | None]]:\n        for key in self.PURE_FLAGS:\n            yield key, self._values.get(key)", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 12272}, "tests/ext/commands/test_params.py::107": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Any", "commands", "pytest"], "enclosing_function": "test_ellipsis", "extracted_code": "", "n_imports_parsed": 7, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_activity.py::56": {"resolved_imports": ["disnake/__init__.py", "disnake/activity.py"], "used_names": [], "enclosing_function": "test_text", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_mentions.py::52": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["AllowedMentions", "Object", "pytest"], "enclosing_function": "test_to_dict", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ui/test_decorators.py::52": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/button.py"], "used_names": ["Any", "assert_type", "ui"], "enclosing_function": "test_default", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 8, "n_files_resolved": 3, "n_chars_extracted": 1281}, "tests/ext/commands/test_params.py::108": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Any", "commands", "pytest"], "enclosing_function": "test_ellipsis", "extracted_code": "", "n_imports_parsed": 7, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_mentions.py::79": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["AllowedMentions", "Object", "pytest"], "enclosing_function": "test_merge", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_activity.py::90": {"resolved_imports": ["disnake/__init__.py", "disnake/activity.py"], "used_names": ["activity"], "enclosing_function": "test_asset_id_activity", "extracted_code": "# Source: disnake/__init__.py\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\nfrom .asset import *\nfrom .audit_logs import *\nfrom .automod import *\nfrom .bans import *\nfrom .channel import *\nfrom .client import *", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 318}, "tests/ext/commands/test_slash_core.py::34": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_qualified_name", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_message.py::35": {"resolved_imports": ["disnake/__init__.py", "disnake/message.py"], "used_names": ["message", "pytest"], "enclosing_function": "test_convert_emoji_reaction__custom", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ui/test_action_row.py::244": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow", "normalize_components", "pytest"], "enclosing_function": "test_normalize_components__actionrow", "extracted_code": "# Source: disnake/ui/action_row.py\ndef normalize_components(\n    components: ComponentInput[NoReturn, NonActionRowChildT], /, modal: bool = False\n) -> Sequence[NonActionRowChildT]: ...\n\ndef normalize_components(\n    components: ComponentInput[ActionRowChildT, NonActionRowChildT], /, modal: bool = False\n) -> Sequence[ActionRow[ActionRowChildT] | NonActionRowChildT]: ...\n\ndef normalize_components(\n    components: ComponentInput[ActionRowChildT, NonActionRowChildT], /, modal: bool = False\n) -> Sequence[ActionRow[ActionRowChildT] | NonActionRowChildT]:\n    \"\"\"Wraps consecutive actionrow-compatible components or lists in `ActionRow`s,\n    while respecting the width limit. Other components are returned as-is.\n\n    If `modal` is `True`, only wraps `TextInput`s in action rows, and returns other (otherwise\n    actionrow-compatible) components as-is.\n    \"\"\"\n    if not isinstance(components, Sequence):\n        components = [components]\n\n    result: list[ActionRow[ActionRowChildT] | NonActionRowChildT] = []\n    auto_row: ActionRow[ActionRowChildT] = ActionRow[ActionRowChildT]()\n\n    wrap_types = TextInput if modal else WrappedComponent\n\n    for component in components:\n        if isinstance(component, wrap_types):\n            # action row child component, try to insert into current row, otherwise create new row\n            try:\n                auto_row.append_item(component)\n            except ValueError:\n                result.append(auto_row)\n                auto_row = ActionRow[ActionRowChildT](component)\n        else:\n            if auto_row.width > 0:\n                # if the current action row has items, finish it\n                result.append(auto_row)\n                auto_row = ActionRow[ActionRowChildT]()\n\n            if isinstance(component, UIComponent):\n                # append non-actionrow-child components as-is\n                # (action rows, v2 components, or actionrow-child components in modals)\n                result.append(component)\n\n            elif isinstance(component, Sequence):\n                result.append(ActionRow[ActionRowChildT](*component))\n\n            else:\n                assert_never(component)\n                msg = (\n                    \"`components` must be a single component, \"\n                    \"a sequence/list of components (or action rows), \"\n                    \"or a nested sequence/list of action row compatible components\"\n                )\n                raise TypeError(msg)\n\n    if auto_row.width > 0:\n        result.append(auto_row)\n\n    return result", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 2532}, "tests/test_permissions.py::306": {"resolved_imports": ["disnake/permissions.py"], "used_names": ["PermissionOverwrite"], "enclosing_function": "test_update", "extracted_code": "# Source: disnake/permissions.py\nclass PermissionOverwrite:\n    r\"\"\"A type that is used to represent a channel specific permission.\n\n    Unlike a regular :class:`Permissions`\\, the default value of a\n    permission is equivalent to :data:`None` and not ``False``. Setting\n    a value to ``False`` is **explicitly** denying that permission,\n    while setting a value to ``True`` is **explicitly** allowing\n    that permission.\n\n    The values supported by this are the same as :class:`Permissions`\n    with the added possibility of it being set to :data:`None`.\n\n    .. collapse:: operations\n\n        .. describe:: x == y\n\n            Checks if two overwrites are equal.\n        .. describe:: x != y\n\n            Checks if two overwrites are not equal.\n        .. describe:: iter(x)\n\n           Returns an iterator of ``(perm, value)`` pairs. This allows it\n           to be, for example, constructed as a dict or a list of pairs.\n           Note that aliases are not shown.\n\n    Parameters\n    ----------\n    **kwargs\n        Set the value of permissions by their name.\n    \"\"\"\n\n    __slots__ = (\"_values\",)\n\n    # n. b. this typechecking block must be first and separate from the secondary one, due to codemodding\n    if TYPE_CHECKING:\n        add_reactions: bool | None\n        administrator: bool | None\n        attach_files: bool | None\n        ban_members: bool | None\n        bypass_slowmode: bool | None\n        change_nickname: bool | None\n        connect: bool | None\n        create_events: bool | None\n        create_forum_threads: bool | None\n        create_guild_expressions: bool | None\n        create_instant_invite: bool | None\n        create_private_threads: bool | None\n        create_public_threads: bool | None\n        deafen_members: bool | None\n        embed_links: bool | None\n        external_emojis: bool | None\n        external_stickers: bool | None\n        kick_members: bool | None\n        manage_channels: bool | None\n        manage_emojis: bool | None\n        manage_emojis_and_stickers: bool | None\n        manage_events: bool | None\n        manage_guild: bool | None\n        manage_guild_expressions: bool | None\n        manage_messages: bool | None\n        manage_nicknames: bool | None\n        manage_permissions: bool | None\n        manage_roles: bool | None\n        manage_threads: bool | None\n        manage_webhooks: bool | None\n        mention_everyone: bool | None\n        moderate_members: bool | None\n        move_members: bool | None\n        mute_members: bool | None\n        pin_messages: bool | None\n        priority_speaker: bool | None\n        read_message_history: bool | None\n        read_messages: bool | None\n        request_to_speak: bool | None\n        send_messages: bool | None\n        send_messages_in_threads: bool | None\n        send_polls: bool | None\n        send_tts_messages: bool | None\n        send_voice_messages: bool | None\n        speak: bool | None\n        start_embedded_activities: bool | None\n        stream: bool | None\n        use_application_commands: bool | None\n        use_embedded_activities: bool | None\n        use_external_apps: bool | None\n        use_external_emojis: bool | None\n        use_external_sounds: bool | None\n        use_external_stickers: bool | None\n        use_slash_commands: bool | None\n        use_soundboard: bool | None\n        use_voice_activation: bool | None\n        view_audit_log: bool | None\n        view_channel: bool | None\n        view_creator_monetization_analytics: bool | None\n        view_guild_insights: bool | None\n\n    if TYPE_CHECKING:\n        VALID_NAMES: ClassVar[set[str]]\n        PURE_FLAGS: ClassVar[set[str]]\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        *,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def __init__(self, **kwargs: bool | None) -> None:\n        self._values: dict[str, bool | None] = {}\n\n        for key, value in kwargs.items():\n            if key not in self.VALID_NAMES:\n                msg = f\"{key!r} is not a valid permission name.\"\n                raise ValueError(msg)\n\n            setattr(self, key, value)\n\n    def __eq__(self, other: object) -> bool:\n        return isinstance(other, PermissionOverwrite) and self._values == other._values\n\n    def _set(self, key: str, value: bool | None) -> None:\n        if value not in (True, None, False):\n            msg = f\"Expected bool or NoneType, received {value.__class__.__name__}\"\n            raise TypeError(msg)\n\n        if value is None:\n            self._values.pop(key, None)\n        else:\n            self._values[key] = value\n\n    def pair(self) -> tuple[Permissions, Permissions]:\n        r\"\"\":class:`tuple`\\[:class:`Permissions`, :class:`Permissions`]: Returns the (allow, deny) pair from this overwrite.\"\"\"\n        allow = Permissions.none()\n        deny = Permissions.none()\n\n        for key, value in self._values.items():\n            if value is True:\n                setattr(allow, key, True)\n            elif value is False:\n                setattr(deny, key, True)\n\n        return allow, deny\n\n    @classmethod\n    def from_pair(cls, allow: Permissions, deny: Permissions) -> Self:\n        \"\"\"Creates an overwrite from an allow/deny pair of :class:`Permissions`.\"\"\"\n        ret = cls()\n        for key, value in allow:\n            if value is True:\n                setattr(ret, key, True)\n\n        for key, value in deny:\n            if value is True:\n                setattr(ret, key, False)\n\n        return ret\n\n    def is_empty(self) -> bool:\n        \"\"\"Checks if the permission overwrite is currently empty.\n\n        An empty permission overwrite is one that has no overwrites set\n        to ``True`` or ``False``.\n\n        Returns\n        -------\n        :class:`bool`\n            Indicates if the overwrite is empty.\n        \"\"\"\n        return len(self._values) == 0\n\n    @overload\n    @_generated\n    def update(\n        self,\n        *,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def update(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def update(self, **kwargs: bool | None) -> None:\n        \"\"\"Bulk updates this permission overwrite object.\n\n        Allows you to set multiple attributes by using keyword\n        arguments. The names must be equivalent to the properties\n        listed. Extraneous key/value pairs will be silently ignored.\n\n        Parameters\n        ----------\n        **kwargs\n            A list of key/value pairs to bulk update with.\n        \"\"\"\n        for key, value in kwargs.items():\n            if key not in self.VALID_NAMES:\n                continue\n\n            setattr(self, key, value)\n\n    def __iter__(self) -> Iterator[tuple[str, bool | None]]:\n        for key in self.PURE_FLAGS:\n            yield key, self._values.get(key)", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 12272}, "tests/test_embeds.py::82": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_len", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ui/test_decorators.py::46": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/button.py"], "used_names": ["Any", "assert_type", "ui"], "enclosing_function": "test_default", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 8, "n_files_resolved": 3, "n_chars_extracted": 1281}, "tests/test_embeds.py::78": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_len", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_embeds.py::202": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_attr_proxy", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ext/commands/test_base_core.py::110": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["commands", "disnake"], "enclosing_function": "test_contexts_guildcommandinteraction", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/test_activity.py::66": {"resolved_imports": ["disnake/__init__.py", "disnake/activity.py"], "used_names": [], "enclosing_function": "test_mp", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ui/test_action_row.py::53": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow", "pytest"], "enclosing_function": "test_append_item", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/ext/commands/test_base_core.py::132": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["commands"], "enclosing_function": "test_decorator_override", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_activity.py::91": {"resolved_imports": ["disnake/__init__.py", "disnake/activity.py"], "used_names": ["activity"], "enclosing_function": "test_asset_id_activity", "extracted_code": "# Source: disnake/__init__.py\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\nfrom .asset import *\nfrom .audit_logs import *\nfrom .automod import *\nfrom .bans import *\nfrom .channel import *\nfrom .client import *", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 318}, "tests/ext/tasks/test_loops.py::19": {"resolved_imports": ["disnake/ext/commands/__init__.py", "disnake/ext/tasks/__init__.py"], "used_names": ["commands", "loop", "pytest"], "enclosing_function": "test_decorator", "extracted_code": "# Source: disnake/ext/tasks/__init__.py\ndef loop(\n    *,\n    seconds: float = ...,\n    minutes: float = ...,\n    hours: float = ...,\n    time: datetime.time | Sequence[datetime.time] = ...,\n    count: int | None = None,\n    reconnect: bool = True,\n    loop: asyncio.AbstractEventLoop = ...,\n) -> Callable[[LF], Loop[LF]]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, P], L_co], *_: P.args, **kwargs: P.kwargs\n) -> Callable[[LF], L_co]: ...\n\ndef loop(\n    cls: Callable[Concatenate[LF, ...], L_co] = Loop[Any],\n    **kwargs: Any,\n) -> Callable[[LF], L_co]:\n    r\"\"\"A decorator that schedules a task in the background for you with\n    optional reconnect logic. The decorator returns a :class:`Loop`.\n\n    Parameters\n    ----------\n    cls: :class:`~collections.abc.Callable`\\[..., :class:`Loop`]\n        A callable (such as a :class:`Loop` subclass) returning an instance of a :class:`Loop`.\n        If provided, the other parameters described below do not apply.\n        Instead, this decorator will accept the same keyword arguments as the passed callable does.\n\n        .. versionadded:: 2.6\n\n    seconds: :class:`float`\n        The number of seconds between every iteration.\n    minutes: :class:`float`\n        The number of minutes between every iteration.\n    hours: :class:`float`\n        The number of hours between every iteration.\n    time: :class:`datetime.time` | :class:`~collections.abc.Sequence`\\[:class:`datetime.time`]\n        The exact times to run this loop at. Either a non-empty list or a single\n        value of :class:`datetime.time` should be passed. Timezones are supported.\n        If no timezone is given for the times, it is assumed to represent UTC time.\n\n        This cannot be used in conjunction with the relative time parameters.\n\n        .. note::\n\n            Duplicate times will be ignored, and only run once.\n\n        .. versionadded:: 2.0\n\n    count: :class:`int` | :data:`None`\n        The number of loops to do, :data:`None` if it should be an infinite loop.\n    reconnect: :class:`bool`\n        Whether to handle errors and restart the task using an exponential back-off algorithm\n        similar to the one used in :meth:`disnake.Client.connect`.\n    loop: :class:`asyncio.AbstractEventLoop`\n        The loop to use to register the task, if not given defaults to the current event loop\n        or creates a new one if there is none.\n\n    Raises\n    ------\n    ValueError\n        An invalid value for the ``count`` or ``time`` parameter was given.\n    TypeError\n        The function was not a coroutine, the ``cls`` parameter was not a callable\n        nor a subclass of ``Loop``, an invalid value for the ``time`` parameter was passed,\n        or the ``time`` parameter was passed in conjunction with relative time parameters.\n    \"\"\"\n    if not callable(cls):\n        msg = \"cls argument must be callable\"\n        raise TypeError(msg)\n\n    def decorator(func: LF) -> L_co:\n        if not iscoroutinefunction(func):\n            msg = \"The decorated function must be a coroutine function.\"\n            raise TypeError(msg)\n\n        return cast(\"type[L_co]\", cls)(func, **kwargs)\n\n    return decorator", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 3144}, "tests/test_permissions.py::14": {"resolved_imports": ["disnake/permissions.py"], "used_names": ["Permissions"], "enclosing_function": "test_init_permissions_keyword_arguments", "extracted_code": "# Source: disnake/permissions.py\nclass Permissions(BaseFlags):\n    \"\"\"Wraps up the Discord permission value.\n\n    The properties provided are two way. You can set and retrieve individual\n    bits using the properties as if they were regular bools. This allows\n    you to edit permissions.\n\n    To construct an object you can pass keyword arguments denoting the permissions\n    to enable or disable.\n    Arguments are applied in order, which notably also means that supplying a flag\n    and its alias will make whatever comes last overwrite the first one; as an example,\n    ``Permissions(external_emojis=True, use_external_emojis=False)`` and\n    ``Permissions(use_external_emojis=True, external_emojis=False)``\n    both result in the same permissions value (``0``).\n\n    .. versionchanged:: 1.3\n        You can now use keyword arguments to initialize :class:`Permissions`\n        similar to :meth:`update`.\n\n    .. collapse:: operations\n\n        .. describe:: x == y\n\n            Checks if two permissions are equal.\n        .. describe:: x != y\n\n            Checks if two permissions are not equal.\n        .. describe:: x <= y\n\n            Checks if a permission is a subset of another permission.\n        .. describe:: x >= y\n\n            Checks if a permission is a superset of another permission.\n        .. describe:: x < y\n\n            Checks if a permission is a strict subset of another permission.\n        .. describe:: x > y\n\n            Checks if a permission is a strict superset of another permission.\n        .. describe:: x | y, x |= y\n\n            Returns a new Permissions instance with all enabled permissions from both x and y.\n            (Using ``|=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: x & y, x &= y\n\n            Returns a new Permissions instance with only permissions enabled on both x and y.\n            (Using ``&=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: x ^ y, x ^= y\n\n            Returns a new Permissions instance with only permissions enabled on one of x or y, but not both.\n            (Using ``^=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: ~x\n\n            Returns a new Permissions instance with all permissions from x inverted.\n\n            .. versionadded:: 2.6\n        .. describe:: hash(x)\n\n               Return the permission's hash.\n        .. describe:: iter(x)\n\n               Returns an iterator of ``(perm, value)`` pairs. This allows it\n               to be, for example, constructed as a dict or a list of pairs.\n               Note that aliases are not shown.\n\n\n        Additionally supported are a few operations on class attributes.\n\n        .. describe:: Permissions.y | Permissions.z, Permissions(y=True) | Permissions.z\n\n            Returns a Permissions instance with all provided permissions enabled.\n\n            .. versionadded:: 2.6\n        .. describe:: ~Permissions.y\n\n            Returns a Permissions instance with all permissions except ``y`` inverted from their default value.\n\n            .. versionadded:: 2.6\n\n    Attributes\n    ----------\n    value: :class:`int`\n        The raw value. This value is a bit array field of a 53-bit integer\n        representing the currently available permissions. You should query\n        permissions via the properties rather than using this raw value.\n    \"\"\"\n\n    __slots__ = ()\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        permissions: int = 0,\n        *,\n        add_reactions: bool = ...,\n        administrator: bool = ...,\n        attach_files: bool = ...,\n        ban_members: bool = ...,\n        bypass_slowmode: bool = ...,\n        change_nickname: bool = ...,\n        connect: bool = ...,\n        create_events: bool = ...,\n        create_forum_threads: bool = ...,\n        create_guild_expressions: bool = ...,\n        create_instant_invite: bool = ...,\n        create_private_threads: bool = ...,\n        create_public_threads: bool = ...,\n        deafen_members: bool = ...,\n        embed_links: bool = ...,\n        external_emojis: bool = ...,\n        external_stickers: bool = ...,\n        kick_members: bool = ...,\n        manage_channels: bool = ...,\n        manage_emojis: bool = ...,\n        manage_emojis_and_stickers: bool = ...,\n        manage_events: bool = ...,\n        manage_guild: bool = ...,\n        manage_guild_expressions: bool = ...,\n        manage_messages: bool = ...,\n        manage_nicknames: bool = ...,\n        manage_permissions: bool = ...,\n        manage_roles: bool = ...,\n        manage_threads: bool = ...,\n        manage_webhooks: bool = ...,\n        mention_everyone: bool = ...,\n        moderate_members: bool = ...,\n        move_members: bool = ...,\n        mute_members: bool = ...,\n        pin_messages: bool = ...,\n        priority_speaker: bool = ...,\n        read_message_history: bool = ...,\n        read_messages: bool = ...,\n        request_to_speak: bool = ...,\n        send_messages: bool = ...,\n        send_messages_in_threads: bool = ...,\n        send_polls: bool = ...,\n        send_tts_messages: bool = ...,\n        send_voice_messages: bool = ...,\n        speak: bool = ...,\n        start_embedded_activities: bool = ...,\n        stream: bool = ...,\n        use_application_commands: bool = ...,\n        use_embedded_activities: bool = ...,\n        use_external_apps: bool = ...,\n        use_external_emojis: bool = ...,\n        use_external_sounds: bool = ...,\n        use_external_stickers: bool = ...,\n        use_slash_commands: bool = ...,\n        use_soundboard: bool = ...,\n        use_voice_activation: bool = ...,\n        view_audit_log: bool = ...,\n        view_channel: bool = ...,\n        view_creator_monetization_analytics: bool = ...,\n        view_guild_insights: bool = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        permissions: int = 0,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def __init__(self, permissions: int = 0, **kwargs: bool) -> None:\n        if not isinstance(permissions, int):\n            msg = f\"Expected int parameter, received {permissions.__class__.__name__} instead.\"\n            raise TypeError(msg)\n\n        self.value = permissions\n        for key, value in kwargs.items():\n            if key not in self.VALID_FLAGS:\n                msg = f\"{key!r} is not a valid permission name.\"\n                raise TypeError(msg)\n            setattr(self, key, value)\n\n    def is_subset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if self has the same or fewer permissions as other.\"\"\"\n        if isinstance(other, Permissions):\n            return (self.value & other.value) == self.value\n        else:\n            msg = f\"cannot compare {self.__class__.__name__} with {other.__class__.__name__}\"\n            raise TypeError(msg)\n\n    def is_superset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if self has the same or more permissions as other.\"\"\"\n        if isinstance(other, Permissions):\n            return (self.value | other.value) == self.value\n        else:\n            msg = f\"cannot compare {self.__class__.__name__} with {other.__class__.__name__}\"\n            raise TypeError(msg)\n\n    def is_strict_subset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if the permissions on self are a strict subset of those on other.\"\"\"\n        return self.is_subset(other) and self != other\n\n    def is_strict_superset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if the permissions on self are a strict superset of those on other.\"\"\"\n        return self.is_superset(other) and self != other\n\n    # the parent uses `Self` for the `other` typehint but we use `Permissions` here for backwards compat.\n    __le__ = is_subset\n    __ge__ = is_superset\n    __lt__ = is_strict_subset\n    __gt__ = is_strict_superset\n\n    @classmethod\n    @cached_creation\n    def none(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        permissions set to ``False``.\n        \"\"\"\n        return cls(0)\n\n    @classmethod\n    @cached_creation\n    def all(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        permissions set to ``True``.\n        \"\"\"\n        return cls(**dict.fromkeys(cls.VALID_FLAGS.keys(), True))\n\n    @classmethod\n    @cached_creation\n    def all_channel(cls) -> Self:\n        \"\"\"A :class:`Permissions` with all channel-specific permissions set to\n        ``True`` and the guild-specific ones set to ``False``. The guild-specific\n        permissions are currently:\n\n        - :attr:`create_guild_expressions`\n        - :attr:`manage_guild_expressions`\n        - :attr:`view_audit_log`\n        - :attr:`view_guild_insights`\n        - :attr:`view_creator_monetization_analytics`\n        - :attr:`manage_guild`\n        - :attr:`change_nickname`\n        - :attr:`manage_nicknames`\n        - :attr:`kick_members`\n        - :attr:`ban_members`\n        - :attr:`moderate_members`\n        - :attr:`administrator`\n\n        .. versionchanged:: 1.7\n           Added :attr:`stream`, :attr:`priority_speaker` and :attr:`use_slash_commands` permissions.\n\n        .. versionchanged:: 2.0\n           Added :attr:`create_public_threads`, :attr:`create_private_threads`, :attr:`manage_threads`,\n           :attr:`use_external_stickers`, :attr:`send_messages_in_threads` and\n           :attr:`request_to_speak` permissions.\n\n        .. versionchanged:: 2.3\n            Added :attr:`use_embedded_activities` permission.\n\n        .. versionchanged:: 2.9\n            Added :attr:`use_soundboard` and :attr:`send_voice_messages` permissions.\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_events` permission.\n        \"\"\"\n        instance = cls.all()\n        instance.update(\n            administrator=False,\n            ban_members=False,\n            change_nickname=False,\n            create_guild_expressions=False,\n            kick_members=False,\n            manage_guild=False,\n            manage_guild_expressions=False,\n            manage_nicknames=False,\n            moderate_members=False,\n            view_audit_log=False,\n            view_guild_insights=False,\n            view_creator_monetization_analytics=False,\n        )\n        return instance\n\n    @classmethod\n    @cached_creation\n    def general(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"General\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 1.7\n           Permission :attr:`read_messages` is now included in the general permissions, but\n           permissions :attr:`administrator`, :attr:`create_instant_invite`, :attr:`kick_members`,\n           :attr:`ban_members`, :attr:`change_nickname` and :attr:`manage_nicknames` are\n           no longer part of the general permissions.\n\n        .. versionchanged:: 2.9\n            Added :attr:`view_creator_monetization_analytics` permission.\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_guild_expressions` permission.\n        \"\"\"\n        return cls(\n            view_channel=True,\n            manage_channels=True,\n            manage_roles=True,\n            create_guild_expressions=True,\n            manage_guild_expressions=True,\n            view_audit_log=True,\n            view_guild_insights=True,\n            view_creator_monetization_analytics=True,\n            manage_webhooks=True,\n            manage_guild=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def membership(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Membership\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.3\n            Added :attr:`moderate_members` permission.\n        \"\"\"\n        return cls(\n            create_instant_invite=True,\n            change_nickname=True,\n            manage_nicknames=True,\n            kick_members=True,\n            ban_members=True,\n            moderate_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def text(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Text\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 1.7\n           Permission :attr:`read_messages` is no longer part of the text permissions.\n           Added :attr:`use_slash_commands` permission.\n\n        .. versionchanged:: 2.0\n           Added :attr:`create_public_threads`, :attr:`create_private_threads`, :attr:`manage_threads`,\n           :attr:`send_messages_in_threads` and :attr:`use_external_stickers` permissions.\n\n        .. versionchanged:: 2.9\n            Added :attr:`send_voice_messages` permission.\n\n        .. versionchanged:: 2.10\n            Moved :attr:`use_application_commands` permission to :attr:`apps`.\n            Added :attr:`send_polls` permission.\n\n        .. versionchanged:: 2.11\n            Added :attr:`pin_messages` permission.\n\n        .. versionchanged:: 2.12\n            Added :attr:`bypass_slowmode` permission.\n        \"\"\"\n        return cls(\n            send_messages=True,\n            send_messages_in_threads=True,\n            create_public_threads=True,\n            create_private_threads=True,\n            embed_links=True,\n            attach_files=True,\n            add_reactions=True,\n            use_external_emojis=True,\n            use_external_stickers=True,\n            mention_everyone=True,\n            manage_messages=True,\n            manage_threads=True,\n            read_message_history=True,\n            send_tts_messages=True,\n            send_voice_messages=True,\n            pin_messages=True,\n            send_polls=True,\n            bypass_slowmode=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def voice(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Voice\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 2.3\n            Added :attr:`use_embedded_activities` permission.\n\n        .. versionchanged:: 2.9\n            Added :attr:`use_soundboard` and :attr:`use_external_sounds` permissions.\n\n        .. versionchanged:: 2.10\n            Moved :attr:`use_embedded_activities` permission to :attr:`apps`.\n        \"\"\"\n        return cls(\n            connect=True,\n            speak=True,\n            stream=True,\n            use_soundboard=True,\n            use_external_sounds=True,\n            use_voice_activation=True,\n            priority_speaker=True,\n            mute_members=True,\n            deafen_members=True,\n            move_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def stage(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Stage Channel\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            request_to_speak=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def stage_moderator(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Stage Moderator\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            manage_channels=True,\n            mute_members=True,\n            move_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def apps(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Apps\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return cls(\n            use_application_commands=True,\n            use_embedded_activities=True,\n            use_external_apps=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def events(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Events\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 2.4\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_events` permission.\n        \"\"\"\n        return cls(\n            create_events=True,\n            manage_events=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def advanced(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Advanced\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            administrator=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def private_channel(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with the\n        best representation of a PrivateChannel's permissions.\n\n        This exists to maintain compatibility with other channel types.\n\n        This is equivalent to :meth:`Permissions.text` with :attr:`~Permissions.view_channel` with the following set to False:\n\n        - :attr:`~Permissions.send_tts_messages`: You cannot send TTS messages in a DM.\n        - :attr:`~Permissions.manage_messages`: You cannot delete others' messages in a DM.\n        - :attr:`~Permissions.manage_threads`: You cannot manage threads in a DM.\n        - :attr:`~Permissions.send_messages_in_threads`: You cannot make threads in a DM.\n        - :attr:`~Permissions.create_public_threads`: You cannot make public threads in a DM.\n        - :attr:`~Permissions.create_private_threads`: You cannot make private threads in a DM.\n        - :attr:`~Permissions.bypass_slowmode`: You cannot enable slowmode in a DM.\n\n        .. versionadded:: 2.4\n        \"\"\"\n        base = cls.text()\n        base.read_messages = True\n        base.send_tts_messages = False\n        base.manage_messages = False\n        base.manage_threads = False\n        base.send_messages_in_threads = False\n        base.create_public_threads = False\n        base.create_private_threads = False\n        base.bypass_slowmode = False\n        return base\n\n    @overload\n    @_generated\n    def update(\n        self,\n        *,\n        add_reactions: bool = ...,\n        administrator: bool = ...,\n        attach_files: bool = ...,\n        ban_members: bool = ...,\n        bypass_slowmode: bool = ...,\n        change_nickname: bool = ...,\n        connect: bool = ...,\n        create_events: bool = ...,\n        create_forum_threads: bool = ...,\n        create_guild_expressions: bool = ...,\n        create_instant_invite: bool = ...,\n        create_private_threads: bool = ...,\n        create_public_threads: bool = ...,\n        deafen_members: bool = ...,\n        embed_links: bool = ...,\n        external_emojis: bool = ...,\n        external_stickers: bool = ...,\n        kick_members: bool = ...,\n        manage_channels: bool = ...,\n        manage_emojis: bool = ...,\n        manage_emojis_and_stickers: bool = ...,\n        manage_events: bool = ...,\n        manage_guild: bool = ...,\n        manage_guild_expressions: bool = ...,\n        manage_messages: bool = ...,\n        manage_nicknames: bool = ...,\n        manage_permissions: bool = ...,\n        manage_roles: bool = ...,\n        manage_threads: bool = ...,\n        manage_webhooks: bool = ...,\n        mention_everyone: bool = ...,\n        moderate_members: bool = ...,\n        move_members: bool = ...,\n        mute_members: bool = ...,\n        pin_messages: bool = ...,\n        priority_speaker: bool = ...,\n        read_message_history: bool = ...,\n        read_messages: bool = ...,\n        request_to_speak: bool = ...,\n        send_messages: bool = ...,\n        send_messages_in_threads: bool = ...,\n        send_polls: bool = ...,\n        send_tts_messages: bool = ...,\n        send_voice_messages: bool = ...,\n        speak: bool = ...,\n        start_embedded_activities: bool = ...,\n        stream: bool = ...,\n        use_application_commands: bool = ...,\n        use_embedded_activities: bool = ...,\n        use_external_apps: bool = ...,\n        use_external_emojis: bool = ...,\n        use_external_sounds: bool = ...,\n        use_external_stickers: bool = ...,\n        use_slash_commands: bool = ...,\n        use_soundboard: bool = ...,\n        use_voice_activation: bool = ...,\n        view_audit_log: bool = ...,\n        view_channel: bool = ...,\n        view_creator_monetization_analytics: bool = ...,\n        view_guild_insights: bool = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def update(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def update(self, **kwargs: bool) -> None:\n        \"\"\"Bulk updates this permission object.\n\n        Allows you to set multiple attributes by using keyword\n        arguments. The names must be equivalent to the properties\n        listed. Extraneous key/value pairs will be silently ignored.\n\n        Arguments are applied in order, similar to the constructor.\n\n        Parameters\n        ----------\n        **kwargs\n            A list of key/value pairs to bulk update permissions with.\n        \"\"\"\n        for key, value in kwargs.items():\n            if key in self.VALID_FLAGS:\n                setattr(self, key, value)\n\n    def handle_overwrite(self, allow: int, deny: int) -> None:\n        # Basically this is what's happening here.\n        # We have an original bit array, e.g. 1010\n        # Then we have another bit array that is 'denied', e.g. 1111\n        # And then we have the last one which is 'allowed', e.g. 0101\n        # We want original OP denied to end up resulting in\n        # whatever is in denied to be set to 0.\n        # So 1010 OP 1111 -> 0000\n        # Then we take this value and look at the allowed values.\n        # And whatever is allowed is set to 1.\n        # So 0000 OP2 0101 -> 0101\n        # The OP is base  & ~denied.\n        # The OP2 is base | allowed.\n        self.value = (self.value & ~deny) | allow\n\n    @flag_value\n    def create_instant_invite(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if the user can create instant invites.\"\"\"\n        return 1 << 0\n\n    @flag_value\n    def kick_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if the user can kick users from the guild.\"\"\"\n        return 1 << 1\n\n    @flag_value\n    def ban_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can ban users from the guild.\"\"\"\n        return 1 << 2\n\n    @flag_value\n    def administrator(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user is an administrator. This role overrides all other permissions.\n\n        This also bypasses all channel-specific overrides.\n        \"\"\"\n        return 1 << 3\n\n    @flag_value\n    def manage_channels(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit, delete, or create channels in the guild.\n\n        This also corresponds to the \"Manage Channel\" channel-specific override.\n        \"\"\"\n        return 1 << 4\n\n    @flag_value\n    def manage_guild(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit guild properties.\"\"\"\n        return 1 << 5\n\n    @flag_value\n    def add_reactions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can add reactions to messages.\"\"\"\n        return 1 << 6\n\n    @flag_value\n    def view_audit_log(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view the guild's audit log.\"\"\"\n        return 1 << 7\n\n    @flag_value\n    def priority_speaker(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can be more easily heard while talking.\"\"\"\n        return 1 << 8\n\n    @flag_value\n    def stream(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can stream in a voice channel.\"\"\"\n        return 1 << 9\n\n    @flag_value\n    def view_channel(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view all or specific channels.\n\n        .. versionadded:: 1.3\n\n        .. versionchanged:: 2.4\n            :attr:`~Permissions.read_messages` is now an alias of :attr:`~Permissions.view_channel`.\n        \"\"\"\n        return 1 << 10\n\n    @make_permission_alias(\"view_channel\")\n    def read_messages(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`view_channel`.\"\"\"\n        return 1 << 10\n\n    @flag_value\n    def send_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send messages from all or specific text channels\n        and create threads in forum/media channels.\n        \"\"\"\n        return 1 << 11\n\n    @make_permission_alias(\"send_messages\")\n    def create_forum_threads(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`send_messages`.\n\n        .. versionadded:: 2.5\n        \"\"\"\n        return 1 << 11\n\n    @flag_value\n    def send_tts_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send TTS messages from all or specific text channels.\"\"\"\n        return 1 << 12\n\n    @flag_value\n    def manage_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can delete messages in a text channel.\n\n        .. note::\n\n            Note that there are currently no ways to edit other people's messages.\n        \"\"\"\n        return 1 << 13\n\n    @flag_value\n    def embed_links(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's messages will automatically be embedded by Discord.\"\"\"\n        return 1 << 14\n\n    @flag_value\n    def attach_files(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send files in their messages.\"\"\"\n        return 1 << 15\n\n    @flag_value\n    def read_message_history(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can read a text channel's previous messages.\"\"\"\n        return 1 << 16\n\n    @flag_value\n    def mention_everyone(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's @everyone or @here will mention everyone in the text channel.\"\"\"\n        return 1 << 17\n\n    @flag_value\n    def external_emojis(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use emojis from other guilds.\"\"\"\n        return 1 << 18\n\n    @make_permission_alias(\"external_emojis\")\n    def use_external_emojis(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`external_emojis`.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 18\n\n    @flag_value\n    def view_guild_insights(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view the guild's insights.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 19\n\n    @flag_value\n    def connect(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can connect to a voice channel.\"\"\"\n        return 1 << 20\n\n    @flag_value\n    def speak(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can speak in a voice channel.\"\"\"\n        return 1 << 21\n\n    @flag_value\n    def mute_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can mute other users.\"\"\"\n        return 1 << 22\n\n    @flag_value\n    def deafen_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can deafen other users.\"\"\"\n        return 1 << 23\n\n    @flag_value\n    def move_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can move users between other voice channels.\"\"\"\n        return 1 << 24\n\n    @flag_value\n    def use_voice_activation(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use voice activation in voice channels.\"\"\"\n        return 1 << 25\n\n    @flag_value\n    def change_nickname(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can change their nickname in the guild.\"\"\"\n        return 1 << 26\n\n    @flag_value\n    def manage_nicknames(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can change other user's nickname in the guild.\"\"\"\n        return 1 << 27\n\n    @flag_value\n    def manage_roles(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create or edit roles less than their role's position.\n\n        This also corresponds to the \"Manage Permissions\" channel-specific override.\n        \"\"\"\n        return 1 << 28\n\n    @make_permission_alias(\"manage_roles\")\n    def manage_permissions(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_roles`.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 28\n\n    @flag_value\n    def manage_webhooks(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create, edit, or delete webhooks.\"\"\"\n        return 1 << 29\n\n    @flag_value\n    def manage_guild_expressions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit or delete\n        emojis, stickers, and soundboard sounds created by all users.\n\n        See also :attr:`create_guild_expressions`.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 30\n\n    @make_permission_alias(\"manage_guild_expressions\")\n    def manage_emojis(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_guild_expressions`.\"\"\"\n        return 1 << 30\n\n    @make_permission_alias(\"manage_guild_expressions\")\n    def manage_emojis_and_stickers(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_guild_expressions`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 30\n\n    @flag_value\n    def use_application_commands(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use application commands.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return 1 << 31\n\n    @make_permission_alias(\"use_application_commands\")\n    def use_slash_commands(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`use_application_commands`.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Became an alias for :attr:`use_application_commands`.\n        \"\"\"\n        return 1 << 31\n\n    @flag_value\n    def request_to_speak(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can request to speak in a stage channel.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return 1 << 32\n\n    @flag_value\n    def manage_events(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit or delete guild scheduled events\n        created by all users.\n\n        See also :attr:`create_events`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 33\n\n    @flag_value\n    def manage_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can manage threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 34\n\n    @flag_value\n    def create_public_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create public threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 35\n\n    @flag_value\n    def create_private_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create private threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 36\n\n    @flag_value\n    def external_stickers(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use stickers from other guilds.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 37\n\n    @make_permission_alias(\"external_stickers\")\n    def use_external_stickers(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`external_stickers`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 37\n\n    @flag_value\n    def send_messages_in_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send messages in threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 38\n\n    @flag_value\n    def use_embedded_activities(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use activities (applications\n        with the :attr:`~ApplicationFlags.embedded` flag) in a voice channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return 1 << 39\n\n    @make_permission_alias(\"use_embedded_activities\")\n    def start_embedded_activities(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`use_embedded_activities`.\n\n        .. versionadded:: 2.3\n\n        .. versionchanged:: 2.6\n            Became an alias for :attr:`use_embedded_activities`.\n        \"\"\"\n        return 1 << 39\n\n    @flag_value\n    def moderate_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can perform limited moderation actions,\n        such as timeouts or editing members' flags.\n\n        .. versionadded:: 2.3\n        \"\"\"\n        return 1 << 40\n\n    @flag_value\n    def view_creator_monetization_analytics(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view role subscription insights.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 41\n\n    @flag_value\n    def use_soundboard(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use the soundboard in voice channels.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 42\n\n    @flag_value\n    def create_guild_expressions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create emojis, stickers,\n        and soundboard sounds, as well as edit and delete the ones they created.\n\n        See also :attr:`manage_guild_expressions`.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 43\n\n    @flag_value\n    def create_events(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create guild scheduled events,\n        as well as edit and delete the ones they created.\n\n        See also :attr:`manage_events`.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 44\n\n    @flag_value\n    def use_external_sounds(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use custom soundboard sounds from other guilds.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 45\n\n    @flag_value\n    def send_voice_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send voice messages.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 46\n\n    @flag_value\n    def send_polls(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send polls.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 49\n\n    @flag_value\n    def use_external_apps(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's apps can send public responses.\n\n        If disabled, users can still use their user-installed applications, but the responses\n        will be forced ephemeral (i.e. only visible to them).\n        Only applies to user-installed apps that are not also installed to the guild.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 50\n\n    @flag_value\n    def pin_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can pin and unpin messages.\n\n        .. versionadded:: 2.11\n        \"\"\"\n        return 1 << 51\n\n    @flag_value\n    def bypass_slowmode(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can bypass slowmode restrictions.\n\n        Bots are unaffected by slowmode regardless of this permission.\n\n        .. versionadded:: 2.12\n        \"\"\"\n        return 1 << 52", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 35157}, "tests/test_flags.py::112": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": ["pytest", "re"], "enclosing_function": "test_flag_value_or", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ui/test_components.py::50": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py"], "used_names": ["pytest", "ui"], "enclosing_function": "test_id_property", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 1281}, "tests/test_embeds.py::42": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_init_empty", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ui/test_select.py::23": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py"], "used_names": ["disnake", "mock", "pytest", "ui"], "enclosing_function": "test_valid", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/test_flags.py::408": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": [], "enclosing_function": "test_iter", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_abc.py::113": {"resolved_imports": ["disnake/__init__.py", "disnake/abc.py"], "used_names": ["GuildChannel"], "enclosing_function": "test_sync_permissions", "extracted_code": "# Source: disnake/abc.py\nclass GuildChannel(ABC):\n    \"\"\"An ABC that details the common operations on a Discord guild channel.\n\n    The following classes implement this ABC:\n\n    - :class:`.TextChannel`\n    - :class:`.VoiceChannel`\n    - :class:`.CategoryChannel`\n    - :class:`.StageChannel`\n    - :class:`.ForumChannel`\n    - :class:`.MediaChannel`\n\n    This ABC must also implement :class:`.abc.Snowflake`.\n\n    Attributes\n    ----------\n    name: :class:`str`\n        The channel name.\n    guild: :class:`.Guild`\n        The guild the channel belongs to.\n    position: :class:`int`\n        The position in the channel list. This is a number that starts at 0.\n        e.g. the top channel is position 0.\n    \"\"\"\n\n    __slots__ = ()\n\n    id: int\n    name: str\n    guild: Guild\n    type: ChannelType\n    position: int\n    category_id: int | None\n    _flags: int\n    _state: ConnectionState\n    _overwrites: list[_Overwrites]\n\n    if TYPE_CHECKING:\n\n        def __init__(\n            self, *, state: ConnectionState, guild: Guild, data: Mapping[str, Any]\n        ) -> None: ...\n\n    def __str__(self) -> str:\n        return self.name\n\n    @property\n    def _sorting_bucket(self) -> int:\n        raise NotImplementedError\n\n    def _update(self, guild: Guild, data: dict[str, Any]) -> None:\n        raise NotImplementedError\n\n    async def _move(\n        self,\n        position: int,\n        parent_id: int | None = None,\n        lock_permissions: bool = False,\n        *,\n        reason: str | None,\n    ) -> None:\n        if position < 0:\n            msg = \"Channel position cannot be less than 0.\"\n            raise ValueError(msg)\n\n        http = self._state.http\n        bucket = self._sorting_bucket\n        channels = [c for c in self.guild.channels if c._sorting_bucket == bucket]\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        channels.sort(key=lambda c: c.position)\n\n        try:\n            # remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # not there somehow lol\n            return\n        else:\n            index = next(\n                (i for i, c in enumerate(channels) if c.position >= position), len(channels)\n            )\n            # add ourselves at our designated position\n            channels.insert(index, self)\n\n        payload: list[ChannelPositionUpdatePayload] = []\n        for index, c in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": c.id, \"position\": index}\n            if parent_id is not MISSING and c.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def _edit(\n        self,\n        *,\n        name: str = MISSING,\n        topic: str | None = MISSING,\n        position: int = MISSING,\n        nsfw: bool = MISSING,\n        sync_permissions: bool = MISSING,\n        category: Snowflake | None = MISSING,\n        slowmode_delay: int | None = MISSING,\n        default_thread_slowmode_delay: int | None = MISSING,\n        default_auto_archive_duration: AnyThreadArchiveDuration | None = MISSING,\n        type: ChannelType = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        bitrate: int = MISSING,\n        user_limit: int = MISSING,\n        rtc_region: str | VoiceRegion | None = MISSING,\n        video_quality_mode: VideoQualityMode = MISSING,\n        flags: ChannelFlags = MISSING,\n        available_tags: Sequence[ForumTag] = MISSING,\n        default_reaction: str | Emoji | PartialEmoji | None = MISSING,\n        default_sort_order: ThreadSortOrder | None = MISSING,\n        default_layout: ThreadLayout = MISSING,\n        reason: str | None = None,\n    ) -> ChannelPayload | None:\n        parent_id: int | None\n        if category is not MISSING:\n            # if category is given, it's either `None` (no parent) or a category channel\n            parent_id = category.id if category else None\n        else:\n            # if it's not given, don't change the category\n            parent_id = MISSING\n\n        rtc_region_payload: str | None\n        if rtc_region is not MISSING:\n            rtc_region_payload = str(rtc_region) if rtc_region is not None else None\n        else:\n            rtc_region_payload = MISSING\n\n        video_quality_mode_payload: int | None\n        if video_quality_mode is not MISSING:\n            video_quality_mode_payload = int(video_quality_mode)\n        else:\n            video_quality_mode_payload = MISSING\n\n        default_auto_archive_duration_payload: int | None\n        if default_auto_archive_duration is not MISSING:\n            default_auto_archive_duration_payload = (\n                int(default_auto_archive_duration)\n                if default_auto_archive_duration is not None\n                else default_auto_archive_duration\n            )\n        else:\n            default_auto_archive_duration_payload = MISSING\n\n        lock_permissions: bool = bool(sync_permissions)\n\n        overwrites_payload: list[PermissionOverwritePayload] = MISSING\n\n        if position is not MISSING:\n            await self._move(\n                position, parent_id=parent_id, lock_permissions=lock_permissions, reason=reason\n            )\n            parent_id = MISSING  # no need to change it again in the edit request below\n        elif lock_permissions:\n            if parent_id is not MISSING:\n                p_id = parent_id\n            else:\n                p_id = self.category_id\n\n            if p_id is not None and (parent := self.guild.get_channel(p_id)):\n                overwrites_payload = [c._asdict() for c in parent._overwrites]\n\n        if overwrites not in (MISSING, None):\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": _Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER,\n                }\n                overwrites_payload.append(payload)\n\n        type_payload: int\n        if type is not MISSING:\n            if not isinstance(type, ChannelType):\n                msg = \"type field must be of type ChannelType\"\n                raise TypeError(msg)\n            type_payload = type.value\n        else:\n            type_payload = MISSING\n\n        flags_payload: int\n        if flags is not MISSING:\n            if not isinstance(flags, ChannelFlags):\n                msg = \"flags field must be of type ChannelFlags\"\n                raise TypeError(msg)\n            flags_payload = flags.value\n        else:\n            flags_payload = MISSING\n\n        available_tags_payload: list[PartialForumTagPayload] = MISSING\n        if available_tags is not MISSING:\n            available_tags_payload = [tag.to_dict() for tag in available_tags]\n\n        default_reaction_emoji_payload: DefaultReactionPayload | None = MISSING\n        if default_reaction is not MISSING:\n            if default_reaction is not None:\n                emoji_name, emoji_id = PartialEmoji._emoji_to_name_id(default_reaction)\n                default_reaction_emoji_payload = {\n                    \"emoji_name\": emoji_name,\n                    \"emoji_id\": emoji_id,\n                }\n            else:\n                default_reaction_emoji_payload = None\n\n        default_sort_order_payload: int | None = MISSING\n        if default_sort_order is not MISSING:\n            default_sort_order_payload = (\n                try_enum_to_int(default_sort_order) if default_sort_order is not None else None\n            )\n\n        default_layout_payload: int = MISSING\n        if default_layout is not MISSING:\n            default_layout_payload = try_enum_to_int(default_layout)\n\n        options: dict[str, Any] = {\n            \"name\": name,\n            \"parent_id\": parent_id,\n            \"topic\": topic,\n            \"bitrate\": bitrate,\n            \"nsfw\": nsfw,\n            \"user_limit\": user_limit,\n            # note: not passing `position` as it already got updated before, if passed\n            \"permission_overwrites\": overwrites_payload,\n            \"rate_limit_per_user\": slowmode_delay,\n            \"default_thread_rate_limit_per_user\": default_thread_slowmode_delay,\n            \"type\": type_payload,\n            \"rtc_region\": rtc_region_payload,\n            \"video_quality_mode\": video_quality_mode_payload,\n            \"default_auto_archive_duration\": default_auto_archive_duration_payload,\n            \"flags\": flags_payload,\n            \"available_tags\": available_tags_payload,\n            \"default_reaction_emoji\": default_reaction_emoji_payload,\n            \"default_sort_order\": default_sort_order_payload,\n            \"default_forum_layout\": default_layout_payload,\n        }\n        options = {k: v for k, v in options.items() if v is not MISSING}\n\n        if options:\n            return await self._state.http.edit_channel(self.id, reason=reason, **options)\n        return None\n\n    def _fill_overwrites(self, data: GuildChannelPayload) -> None:\n        self._overwrites = []\n        everyone_index = 0\n        everyone_id = self.guild.id\n\n        for index, overridden in enumerate(data.get(\"permission_overwrites\", [])):\n            overwrite = _Overwrites(overridden)\n            self._overwrites.append(overwrite)\n\n            if overwrite.type == _Overwrites.MEMBER:\n                continue\n\n            if overwrite.id == everyone_id:\n                # the @everyone role is not guaranteed to be the first one\n                # in the list of permission overwrites, however the permission\n                # resolution code kind of requires that it is the first one in\n                # the list since it is special. So we need the index so we can\n                # swap it to be the first one.\n                everyone_index = index\n\n        # do the swap\n        tmp = self._overwrites\n        if tmp:\n            tmp[everyone_index], tmp[0] = tmp[0], tmp[everyone_index]\n\n    @property\n    def changed_roles(self) -> list[Role]:\n        r\"\"\":class:`list`\\[:class:`.Role`]: Returns a list of roles that have been overridden from\n        their default values in the :attr:`.Guild.roles` attribute.\n        \"\"\"\n        ret: list[Role] = []\n        g = self.guild\n        for overwrite in filter(lambda o: o.is_role(), self._overwrites):\n            role = g.get_role(overwrite.id)\n            if role is None:\n                continue\n\n            role = copy.copy(role)\n            role.permissions.handle_overwrite(overwrite.allow, overwrite.deny)\n            ret.append(role)\n        return ret\n\n    @property\n    def mention(self) -> str:\n        \"\"\":class:`str`: The string that allows you to mention the channel.\"\"\"\n        return f\"<#{self.id}>\"\n\n    @property\n    def created_at(self) -> datetime:\n        \"\"\":class:`datetime.datetime`: Returns the channel's creation time in UTC.\"\"\"\n        return utils.snowflake_time(self.id)\n\n    def overwrites_for(self, obj: Role | User) -> PermissionOverwrite:\n        \"\"\"Returns the channel-specific overwrites for a member or a role.\n\n        Parameters\n        ----------\n        obj: :class:`.Role` | :class:`.abc.User`\n            The role or user denoting\n            whose overwrite to get.\n\n        Returns\n        -------\n        :class:`~disnake.PermissionOverwrite`\n            The permission overwrites for this object.\n        \"\"\"\n        predicate: Callable[[_Overwrites], bool]\n        if isinstance(obj, User):\n            predicate = lambda p: p.is_member()\n        elif isinstance(obj, Role):\n            predicate = lambda p: p.is_role()\n        else:\n            predicate = lambda p: True\n\n        for overwrite in filter(predicate, self._overwrites):\n            if overwrite.id == obj.id:\n                allow = Permissions(overwrite.allow)\n                deny = Permissions(overwrite.deny)\n                return PermissionOverwrite.from_pair(allow, deny)\n\n        return PermissionOverwrite()\n\n    @property\n    def overwrites(self) -> dict[Role | Member, PermissionOverwrite]:\n        r\"\"\"Returns all of the channel's overwrites.\n\n        This is returned as a dictionary where the key contains the target which\n        can be either a :class:`~disnake.Role` or a :class:`~disnake.Member` and the value is the\n        overwrite as a :class:`~disnake.PermissionOverwrite`.\n\n        Returns\n        -------\n        :class:`dict`\\[:class:`~disnake.Role` | :class:`~disnake.Member`, :class:`~disnake.PermissionOverwrite`]\n            The channel's permission overwrites.\n        \"\"\"\n        ret = {}\n        for ow in self._overwrites:\n            allow = Permissions(ow.allow)\n            deny = Permissions(ow.deny)\n            overwrite = PermissionOverwrite.from_pair(allow, deny)\n            target = None\n\n            if ow.is_role():\n                target = self.guild.get_role(ow.id)\n            elif ow.is_member():\n                target = self.guild.get_member(ow.id)\n\n            # TODO: There is potential data loss here in the non-chunked\n            # case, i.e. target is None because get_member returned nothing.\n            # This can be fixed with a slight breaking change to the return type,\n            # i.e. adding disnake.Object to the list of it\n            # However, for now this is an acceptable compromise.\n            if target is not None:\n                ret[target] = overwrite\n        return ret\n\n    @property\n    def category(self) -> CategoryChannel | None:\n        \"\"\":class:`~disnake.CategoryChannel` | :data:`None`: The category this channel belongs to.\n\n        If there is no category then this is :data:`None`.\n        \"\"\"\n        if isinstance(self.guild, Object):\n            return None\n        return self.guild.get_channel(self.category_id)  # pyright: ignore[reportArgumentType, reportReturnType]\n\n    @property\n    def permissions_synced(self) -> bool:\n        \"\"\":class:`bool`: Whether or not the permissions for this channel are synced with the\n        category it belongs to.\n\n        If there is no category then this is ``False``.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self.category_id is None or isinstance(self.guild, Object):\n            return False\n\n        category = self.guild.get_channel(self.category_id)\n        return bool(category and category.overwrites == self.overwrites)\n\n    @property\n    def flags(self) -> ChannelFlags:\n        \"\"\":class:`.ChannelFlags`: The channel flags for this channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return ChannelFlags._from_value(self._flags)\n\n    @property\n    def jump_url(self) -> str:\n        \"\"\"A URL that can be used to jump to this channel.\n\n        .. versionadded:: 2.4\n\n        .. note::\n\n            This exists for all guild channels but may not be usable by the client for all guild channel types.\n        \"\"\"\n        return f\"https://discord.com/channels/{self.guild.id}/{self.id}\"\n\n    def _apply_implict_permissions(self, base: Permissions) -> None:\n        # if you can't send a message in a channel then you can't have certain\n        # permissions as well\n        if not base.send_messages:\n            base.send_tts_messages = False\n            base.send_voice_messages = False\n            base.send_polls = False\n            base.mention_everyone = False\n            base.embed_links = False\n            base.attach_files = False\n\n        # if you can't view a channel then you have no permissions there\n        if not base.view_channel:\n            denied = Permissions.all_channel()\n            base.value &= ~denied.value\n\n    def permissions_for(\n        self,\n        obj: Member | Role,\n        /,\n        *,\n        ignore_timeout: bool = MISSING,\n    ) -> Permissions:\n        \"\"\"Handles permission resolution for the :class:`~disnake.Member`\n        or :class:`~disnake.Role`.\n\n        This function takes into consideration the following cases:\n\n        - Guild owner\n        - Guild roles\n        - Channel overrides\n        - Member overrides\n        - Timeouts\n\n        If a :class:`~disnake.Role` is passed, then it checks the permissions\n        someone with that role would have, which is essentially:\n\n        - The default role permissions\n        - The permissions of the role used as a parameter\n        - The default role permission overwrites\n        - The permission overwrites of the role used as a parameter\n\n        .. note::\n            If the channel originated from an :class:`.Interaction` and\n            the :attr:`.guild` attribute is unavailable, such as with\n            user-installed applications in guilds, this method will not work\n            due to an API limitation.\n            Consider using :attr:`.Interaction.permissions` or :attr:`~.Interaction.app_permissions` instead.\n\n        .. versionchanged:: 2.0\n            The object passed in can now be a role object.\n\n        Parameters\n        ----------\n        obj: :class:`~disnake.Member` | :class:`~disnake.Role`\n            The object to resolve permissions for. This could be either\n            a member or a role. If it's a role then member overwrites\n            are not computed.\n        ignore_timeout: :class:`bool`\n            Whether or not to ignore the user's timeout.\n            Defaults to ``False``.\n\n            .. versionadded:: 2.4\n\n            .. note::\n\n                This only applies to :class:`~disnake.Member` objects.\n\n            .. versionchanged:: 2.6\n\n                The default was changed to ``False``.\n\n        Raises\n        ------\n        TypeError\n            ``ignore_timeout`` is only supported for :class:`~disnake.Member` objects.\n\n        Returns\n        -------\n        :class:`~disnake.Permissions`\n            The resolved permissions for the member or role.\n        \"\"\"\n        # The current cases can be explained as:\n        # Guild owner get all permissions -- no questions asked. Otherwise...\n        # The @everyone role gets the first application.\n        # After that, the applied roles that the user has in the channel\n        # (or otherwise) are then OR'd together.\n        # After the role permissions are resolved, the member permissions\n        # have to take into effect.\n        # After all that is done.. you have to do the following:\n\n        # The operation first takes into consideration the denied\n        # and then the allowed.\n\n        # Timeouted users have only view_channel and read_message_history\n        # if they already have them.\n        if ignore_timeout is not MISSING and isinstance(obj, Role):\n            msg = \"ignore_timeout is only supported for disnake.Member objects\"\n            raise TypeError(msg)\n\n        if ignore_timeout is MISSING:\n            ignore_timeout = False\n\n        if self.guild.owner_id == obj.id:\n            return Permissions.all()\n\n        default = self.guild.default_role\n        base = Permissions(default.permissions.value)\n\n        # Handle the role case first\n        if isinstance(obj, Role):\n            base.value |= obj._permissions\n\n            if base.administrator:\n                return Permissions.all()\n\n            # Apply @everyone allow/deny first since it's special\n            try:\n                maybe_everyone = self._overwrites[0]\n                if maybe_everyone.id == self.guild.id:\n                    base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n            except IndexError:\n                pass\n\n            if obj.is_default():\n                return base\n\n            overwrite = utils.get(self._overwrites, type=_Overwrites.ROLE, id=obj.id)\n            if overwrite is not None:\n                base.handle_overwrite(overwrite.allow, overwrite.deny)\n\n            return base\n\n        roles = obj._roles\n        get_role = self.guild.get_role\n\n        # Apply guild roles that the member has.\n        for role_id in roles:\n            role = get_role(role_id)\n            if role is not None:\n                base.value |= role._permissions\n\n        # Guild-wide Administrator -> True for everything\n        # Bypass all channel-specific overrides\n        if base.administrator:\n            return Permissions.all()\n\n        # Apply @everyone allow/deny first since it's special\n        try:\n            maybe_everyone = self._overwrites[0]\n            if maybe_everyone.id == self.guild.id:\n                base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n                remaining_overwrites = self._overwrites[1:]\n            else:\n                remaining_overwrites = self._overwrites\n        except IndexError:\n            remaining_overwrites = self._overwrites\n\n        denies = 0\n        allows = 0\n\n        # Apply channel specific role permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_role() and roles.has(overwrite.id):\n                denies |= overwrite.deny\n                allows |= overwrite.allow\n\n        base.handle_overwrite(allow=allows, deny=denies)\n\n        # Apply member specific permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_member() and overwrite.id == obj.id:\n                base.handle_overwrite(allow=overwrite.allow, deny=overwrite.deny)\n                break\n\n        # if you have a timeout then you can't have any permissions\n        # except read messages and read message history\n        if not ignore_timeout and obj.current_timeout:\n            allowed = Permissions(view_channel=True, read_message_history=True)\n            base.value &= allowed.value\n\n        return base\n\n    async def delete(self, *, reason: str | None = None) -> None:\n        \"\"\"|coro|\n\n        Deletes the channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to do this.\n\n        Parameters\n        ----------\n        reason: :class:`str` | :data:`None`\n            The reason for deleting this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to delete the channel.\n        NotFound\n            The channel was not found or was already deleted.\n        HTTPException\n            Deleting the channel failed.\n        \"\"\"\n        await self._state.http.delete_channel(self.id, reason=reason)\n\n    @overload\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        overwrite: PermissionOverwrite | None = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_overload_with_permissions\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        reason: str | None = ...,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    async def set_permissions(\n        self,\n        target,\n        *,\n        overwrite: PermissionOverwrite | None = MISSING,\n        reason: str | None = None,\n        **permissions,\n    ) -> None:\n        \"\"\"|coro|\n\n        Sets the channel specific permission overwrites for a target in the\n        channel.\n\n        The ``target`` parameter should either be a :class:`.Member` or a\n        :class:`.Role` that belongs to guild.\n\n        The ``overwrite`` parameter, if given, must either be :data:`None` or\n        :class:`.PermissionOverwrite`. For convenience, you can pass in\n        keyword arguments denoting :class:`.Permissions` attributes. If this is\n        done, then you cannot mix the keyword arguments with the ``overwrite``\n        parameter.\n\n        If the ``overwrite`` parameter is :data:`None`, then the permission\n        overwrites are deleted.\n\n        You must have :attr:`.Permissions.manage_roles` permission to do this.\n\n        .. note::\n\n            This method *replaces* the old overwrites with the ones given.\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` instead of ``InvalidArgument``.\n\n        Examples\n        --------\n        Setting allow and deny: ::\n\n            await message.channel.set_permissions(message.author, view_channel=True,\n                                                                  send_messages=False)\n\n        Deleting overwrites ::\n\n            await channel.set_permissions(member, overwrite=None)\n\n        Using :class:`.PermissionOverwrite` ::\n\n            overwrite = disnake.PermissionOverwrite()\n            overwrite.send_messages = False\n            overwrite.view_channel = True\n            await channel.set_permissions(member, overwrite=overwrite)\n\n        Parameters\n        ----------\n        target: :class:`.Member` | :class:`.Role`\n            The member or role to overwrite permissions for.\n        overwrite: :class:`.PermissionOverwrite` | :data:`None`\n            The permissions to allow and deny to the target, or :data:`None` to\n            delete the overwrite.\n        **permissions\n            A keyword argument list of permissions to set for ease of use.\n            Cannot be mixed with ``overwrite``.\n        reason: :class:`str` | :data:`None`\n            The reason for doing this action. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to edit channel specific permissions.\n        HTTPException\n            Editing channel specific permissions failed.\n        NotFound\n            The role or member being edited is not part of the guild.\n        TypeError\n            ``overwrite`` is invalid,\n            the target type was not :class:`.Role` or :class:`.Member`,\n            both keyword arguments and ``overwrite`` were provided,\n            or invalid permissions were provided as keyword arguments.\n        \"\"\"\n        http = self._state.http\n\n        if isinstance(target, User):\n            perm_type = _Overwrites.MEMBER\n        elif isinstance(target, Role):\n            perm_type = _Overwrites.ROLE\n        else:\n            msg = \"target parameter must be either Member or Role\"\n            raise TypeError(msg)\n\n        if overwrite is MISSING:\n            if len(permissions) == 0:\n                msg = \"No overwrite provided.\"\n                raise TypeError(msg)\n            try:\n                overwrite = PermissionOverwrite(**permissions)\n            except (ValueError, TypeError) as e:\n                msg = \"Invalid permissions given to keyword arguments.\"\n                raise TypeError(msg) from e\n        else:\n            if len(permissions) > 0:\n                msg = \"Cannot mix overwrite and keyword arguments.\"\n                raise TypeError(msg)\n\n        # TODO: wait for event\n\n        if overwrite is None:\n            await http.delete_channel_permissions(self.id, target.id, reason=reason)\n        elif isinstance(overwrite, PermissionOverwrite):\n            (allow, deny) = overwrite.pair()\n            await http.edit_channel_permissions(\n                self.id, target.id, allow.value, deny.value, perm_type, reason=reason\n            )\n        else:\n            msg = \"Invalid overwrite type provided.\"\n            raise TypeError(msg)\n\n    async def _clone_impl(\n        self,\n        base_attrs: dict[str, Any],\n        *,\n        name: str | None = None,\n        category: Snowflake | None = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        reason: str | None = None,\n    ) -> Self:\n        # if the overwrites are MISSING, defaults to the\n        # original permissions of the channel\n        overwrites_payload: list[PermissionOverwritePayload]\n        if overwrites is not MISSING:\n            if not isinstance(overwrites, dict):\n                msg = \"overwrites parameter expects a dict.\"\n                raise TypeError(msg)\n\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": (_Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER),\n                }\n                overwrites_payload.append(payload)\n        else:\n            overwrites_payload = [x._asdict() for x in self._overwrites]\n        base_attrs[\"permission_overwrites\"] = overwrites_payload\n        if category is not MISSING:\n            base_attrs[\"parent_id\"] = category.id if category else None\n        else:\n            # if no category was given don't change the category\n            base_attrs[\"parent_id\"] = self.category_id\n        base_attrs[\"name\"] = name or self.name\n        channel_type = base_attrs.get(\"type\") or self.type.value\n        guild_id = self.guild.id\n        cls = self.__class__\n        data = await self._state.http.create_channel(\n            guild_id, channel_type, reason=reason, **base_attrs\n        )\n        obj = cls(state=self._state, guild=self.guild, data=data)\n\n        # temporarily add it to the cache\n        self.guild._channels[obj.id] = obj  # pyright: ignore[reportArgumentType]\n        return obj\n\n    async def clone(self, *, name: str | None = None, reason: str | None = None) -> Self:\n        \"\"\"|coro|\n\n        Clones this channel. This creates a channel with the same properties\n        as this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. versionadded:: 1.1\n\n        Parameters\n        ----------\n        name: :class:`str` | :data:`None`\n            The name of the new channel. If not provided, defaults to this channel name.\n        reason: :class:`str` | :data:`None`\n            The reason for cloning this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have the proper permissions to create this channel.\n        HTTPException\n            Creating the channel failed.\n\n        Returns\n        -------\n        :class:`.abc.GuildChannel`\n            The channel that was created.\n        \"\"\"\n        raise NotImplementedError\n\n    @overload\n    async def move(\n        self,\n        *,\n        beginning: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        end: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        before: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        after: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    async def move(self, **kwargs: Any) -> None:\n        \"\"\"|coro|\n\n        A rich interface to help move a channel relative to other channels.\n\n        If exact position movement is required, ``edit`` should be used instead.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. note::\n\n            Voice channels will always be sorted below text channels.\n            This is a Discord limitation.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` or :exc:`ValueError` instead of ``InvalidArgument``.\n\n        Parameters\n        ----------\n        beginning: :class:`bool`\n            Whether to move the channel to the beginning of the\n            channel list (or category if given).\n            This is mutually exclusive with ``end``, ``before``, and ``after``.\n        end: :class:`bool`\n            Whether to move the channel to the end of the\n            channel list (or category if given).\n            This is mutually exclusive with ``beginning``, ``before``, and ``after``.\n        before: :class:`.abc.Snowflake`\n            The channel that should be before our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``after``.\n        after: :class:`.abc.Snowflake`\n            The channel that should be after our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``before``.\n        offset: :class:`int`\n            The number of channels to offset the move by. For example,\n            an offset of ``2`` with ``beginning=True`` would move\n            it 2 after the beginning. A positive number moves it below\n            while a negative number moves it above. Note that this\n            number is relative and computed after the ``beginning``,\n            ``end``, ``before``, and ``after`` parameters.\n        category: :class:`.abc.Snowflake` | :data:`None`\n            The category to move this channel under.\n            If :data:`None` is given then it moves it out of the category.\n            This parameter is ignored if moving a category channel.\n        sync_permissions: :class:`bool`\n            Whether to sync the permissions with the category (if given).\n        reason: :class:`str` | :data:`None`\n            The reason for moving this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to move the channel.\n        HTTPException\n            Moving the channel failed.\n        TypeError\n            A bad mix of arguments were passed.\n        ValueError\n            An invalid position was given.\n        \"\"\"\n        if not kwargs:\n            return\n\n        beginning, end = kwargs.get(\"beginning\"), kwargs.get(\"end\")\n        before, after = kwargs.get(\"before\"), kwargs.get(\"after\")\n        offset = kwargs.get(\"offset\", 0)\n        if sum(bool(a) for a in (beginning, end, before, after)) > 1:\n            msg = \"Only one of [before, after, end, beginning] can be used.\"\n            raise TypeError(msg)\n\n        bucket = self._sorting_bucket\n        parent_id = kwargs.get(\"category\", MISSING)\n        if parent_id not in (MISSING, None):\n            parent_id = parent_id.id\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == parent_id\n            ]\n        else:\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == self.category_id\n            ]\n\n        channels.sort(key=lambda c: (c.position, c.id))\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        try:\n            # Try to remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # If we're not there then it's probably due to not being in the category\n            pass\n\n        index = None\n        if beginning:\n            index = 0\n        elif end:\n            index = len(channels)\n        elif before:\n            index = next((i for i, c in enumerate(channels) if c.id == before.id), None)\n        elif after:\n            index = next((i + 1 for i, c in enumerate(channels) if c.id == after.id), None)\n\n        if index is None:\n            msg = \"Could not resolve appropriate move position\"\n            raise ValueError(msg)\n\n        channels.insert(max((index + offset), 0), self)\n        payload: list[ChannelPositionUpdatePayload] = []\n        lock_permissions = kwargs.get(\"sync_permissions\", False)\n        reason = kwargs.get(\"reason\")\n        for index, channel in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": channel.id, \"position\": index}\n            if parent_id is not MISSING and channel.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await self._state.http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def create_invite(\n        self,\n        *,\n        reason: str | None = None,\n        max_age: int = 0,\n        max_uses: int = 0,\n        temporary: bool = False,\n        unique: bool = True,\n        target_type: InviteTarget | None = None,\n        target_user: User | None = None,\n        target_application: Snowflake | PartyType | None = None,\n        guild_scheduled_event: GuildScheduledEvent | None = None,\n    ) -> Invite:\n        \"\"\"|coro|\n\n        Creates an instant invite from a text or voice channel.\n\n        You must have :attr:`.Permissions.create_instant_invite` permission to\n        do this.\n\n        Parameters\n        ----------\n        max_age: :class:`int`\n            How long the invite should last in seconds. If set to ``0``, then the invite\n            doesn't expire. Defaults to ``0``.\n        max_uses: :class:`int`\n            How many uses the invite could be used for. If it's 0 then there\n            are unlimited uses. Defaults to ``0``.\n        temporary: :class:`bool`\n            Whether the invite grants temporary membership\n            (i.e. they get kicked after they disconnect). Defaults to ``False``.\n        unique: :class:`bool`\n            Whether a unique invite URL should be created. Defaults to ``True``.\n            If this is set to ``False`` then it will return a previously created\n            invite.\n        target_type: :class:`.InviteTarget` | :data:`None`\n            The type of target for the voice channel invite, if any.\n\n            .. versionadded:: 2.0\n\n        target_user: :class:`User` | :data:`None`\n            The user whose stream to display for this invite, required if ``target_type`` is :attr:`.InviteTarget.stream`.\n            The user must be streaming in the channel.\n\n            .. versionadded:: 2.0\n\n        target_application: :class:`.Snowflake` | :data:`None`\n            The ID of the embedded application for the invite, required if ``target_type`` is :attr:`.InviteTarget.embedded_application`.\n\n            .. versionadded:: 2.0\n\n            .. versionchanged:: 2.9\n                ``PartyType`` is deprecated, and :class:`.Snowflake` should be used instead.\n\n        guild_scheduled_event: :class:`.GuildScheduledEvent` | :data:`None`\n            The guild scheduled event to include with the invite.\n\n            .. versionadded:: 2.3\n\n        reason: :class:`str` | :data:`None`\n            The reason for creating this invite. Shows up on the audit log.\n\n        Raises\n        ------\n        HTTPException\n            Invite creation failed.\n        NotFound\n            The channel that was passed is a category or an invalid channel.\n\n        Returns\n        -------\n        :class:`.Invite`\n            The newly created invite.\n        \"\"\"\n        if isinstance(target_application, PartyType):\n            utils.warn_deprecated(\n                \"PartyType is deprecated and will be removed in future version\",\n                stacklevel=2,\n            )\n            target_application = Object(target_application.value)\n        data = await self._state.http.create_invite(\n            self.id,\n            reason=reason,\n            max_age=max_age,\n            max_uses=max_uses,\n            temporary=temporary,\n            unique=unique,\n            target_type=try_enum_to_int(target_type),\n            target_user_id=target_user.id if target_user else None,\n            target_application_id=target_application.id if target_application else None,\n        )\n        invite = Invite.from_incomplete(data=data, state=self._state)\n        invite.guild_scheduled_event = guild_scheduled_event\n        return invite\n\n    async def invites(self) -> list[Invite]:\n        r\"\"\"|coro|\n\n        Returns a list of all active instant invites from this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to use this.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to get the information.\n        HTTPException\n            An error occurred while fetching the information.\n\n        Returns\n        -------\n        :class:`list`\\[:class:`.Invite`]\n            The list of invites that are currently active.\n        \"\"\"\n        state = self._state\n        data = await state.http.invites_from_channel(self.id)\n        guild = self.guild\n        return [Invite(state=state, data=invite, channel=self, guild=guild) for invite in data]", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 43721}, "tests/ui/test_select.py::22": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py"], "used_names": ["disnake", "mock", "pytest", "ui"], "enclosing_function": "test_valid", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/test_abc.py::68": {"resolved_imports": ["disnake/__init__.py", "disnake/abc.py"], "used_names": ["GuildChannel", "disnake", "mock"], "enclosing_function": "test_all", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\n\n\n# Source: disnake/abc.py\nclass GuildChannel(ABC):\n    \"\"\"An ABC that details the common operations on a Discord guild channel.\n\n    The following classes implement this ABC:\n\n    - :class:`.TextChannel`\n    - :class:`.VoiceChannel`\n    - :class:`.CategoryChannel`\n    - :class:`.StageChannel`\n    - :class:`.ForumChannel`\n    - :class:`.MediaChannel`\n\n    This ABC must also implement :class:`.abc.Snowflake`.\n\n    Attributes\n    ----------\n    name: :class:`str`\n        The channel name.\n    guild: :class:`.Guild`\n        The guild the channel belongs to.\n    position: :class:`int`\n        The position in the channel list. This is a number that starts at 0.\n        e.g. the top channel is position 0.\n    \"\"\"\n\n    __slots__ = ()\n\n    id: int\n    name: str\n    guild: Guild\n    type: ChannelType\n    position: int\n    category_id: int | None\n    _flags: int\n    _state: ConnectionState\n    _overwrites: list[_Overwrites]\n\n    if TYPE_CHECKING:\n\n        def __init__(\n            self, *, state: ConnectionState, guild: Guild, data: Mapping[str, Any]\n        ) -> None: ...\n\n    def __str__(self) -> str:\n        return self.name\n\n    @property\n    def _sorting_bucket(self) -> int:\n        raise NotImplementedError\n\n    def _update(self, guild: Guild, data: dict[str, Any]) -> None:\n        raise NotImplementedError\n\n    async def _move(\n        self,\n        position: int,\n        parent_id: int | None = None,\n        lock_permissions: bool = False,\n        *,\n        reason: str | None,\n    ) -> None:\n        if position < 0:\n            msg = \"Channel position cannot be less than 0.\"\n            raise ValueError(msg)\n\n        http = self._state.http\n        bucket = self._sorting_bucket\n        channels = [c for c in self.guild.channels if c._sorting_bucket == bucket]\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        channels.sort(key=lambda c: c.position)\n\n        try:\n            # remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # not there somehow lol\n            return\n        else:\n            index = next(\n                (i for i, c in enumerate(channels) if c.position >= position), len(channels)\n            )\n            # add ourselves at our designated position\n            channels.insert(index, self)\n\n        payload: list[ChannelPositionUpdatePayload] = []\n        for index, c in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": c.id, \"position\": index}\n            if parent_id is not MISSING and c.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def _edit(\n        self,\n        *,\n        name: str = MISSING,\n        topic: str | None = MISSING,\n        position: int = MISSING,\n        nsfw: bool = MISSING,\n        sync_permissions: bool = MISSING,\n        category: Snowflake | None = MISSING,\n        slowmode_delay: int | None = MISSING,\n        default_thread_slowmode_delay: int | None = MISSING,\n        default_auto_archive_duration: AnyThreadArchiveDuration | None = MISSING,\n        type: ChannelType = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        bitrate: int = MISSING,\n        user_limit: int = MISSING,\n        rtc_region: str | VoiceRegion | None = MISSING,\n        video_quality_mode: VideoQualityMode = MISSING,\n        flags: ChannelFlags = MISSING,\n        available_tags: Sequence[ForumTag] = MISSING,\n        default_reaction: str | Emoji | PartialEmoji | None = MISSING,\n        default_sort_order: ThreadSortOrder | None = MISSING,\n        default_layout: ThreadLayout = MISSING,\n        reason: str | None = None,\n    ) -> ChannelPayload | None:\n        parent_id: int | None\n        if category is not MISSING:\n            # if category is given, it's either `None` (no parent) or a category channel\n            parent_id = category.id if category else None\n        else:\n            # if it's not given, don't change the category\n            parent_id = MISSING\n\n        rtc_region_payload: str | None\n        if rtc_region is not MISSING:\n            rtc_region_payload = str(rtc_region) if rtc_region is not None else None\n        else:\n            rtc_region_payload = MISSING\n\n        video_quality_mode_payload: int | None\n        if video_quality_mode is not MISSING:\n            video_quality_mode_payload = int(video_quality_mode)\n        else:\n            video_quality_mode_payload = MISSING\n\n        default_auto_archive_duration_payload: int | None\n        if default_auto_archive_duration is not MISSING:\n            default_auto_archive_duration_payload = (\n                int(default_auto_archive_duration)\n                if default_auto_archive_duration is not None\n                else default_auto_archive_duration\n            )\n        else:\n            default_auto_archive_duration_payload = MISSING\n\n        lock_permissions: bool = bool(sync_permissions)\n\n        overwrites_payload: list[PermissionOverwritePayload] = MISSING\n\n        if position is not MISSING:\n            await self._move(\n                position, parent_id=parent_id, lock_permissions=lock_permissions, reason=reason\n            )\n            parent_id = MISSING  # no need to change it again in the edit request below\n        elif lock_permissions:\n            if parent_id is not MISSING:\n                p_id = parent_id\n            else:\n                p_id = self.category_id\n\n            if p_id is not None and (parent := self.guild.get_channel(p_id)):\n                overwrites_payload = [c._asdict() for c in parent._overwrites]\n\n        if overwrites not in (MISSING, None):\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": _Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER,\n                }\n                overwrites_payload.append(payload)\n\n        type_payload: int\n        if type is not MISSING:\n            if not isinstance(type, ChannelType):\n                msg = \"type field must be of type ChannelType\"\n                raise TypeError(msg)\n            type_payload = type.value\n        else:\n            type_payload = MISSING\n\n        flags_payload: int\n        if flags is not MISSING:\n            if not isinstance(flags, ChannelFlags):\n                msg = \"flags field must be of type ChannelFlags\"\n                raise TypeError(msg)\n            flags_payload = flags.value\n        else:\n            flags_payload = MISSING\n\n        available_tags_payload: list[PartialForumTagPayload] = MISSING\n        if available_tags is not MISSING:\n            available_tags_payload = [tag.to_dict() for tag in available_tags]\n\n        default_reaction_emoji_payload: DefaultReactionPayload | None = MISSING\n        if default_reaction is not MISSING:\n            if default_reaction is not None:\n                emoji_name, emoji_id = PartialEmoji._emoji_to_name_id(default_reaction)\n                default_reaction_emoji_payload = {\n                    \"emoji_name\": emoji_name,\n                    \"emoji_id\": emoji_id,\n                }\n            else:\n                default_reaction_emoji_payload = None\n\n        default_sort_order_payload: int | None = MISSING\n        if default_sort_order is not MISSING:\n            default_sort_order_payload = (\n                try_enum_to_int(default_sort_order) if default_sort_order is not None else None\n            )\n\n        default_layout_payload: int = MISSING\n        if default_layout is not MISSING:\n            default_layout_payload = try_enum_to_int(default_layout)\n\n        options: dict[str, Any] = {\n            \"name\": name,\n            \"parent_id\": parent_id,\n            \"topic\": topic,\n            \"bitrate\": bitrate,\n            \"nsfw\": nsfw,\n            \"user_limit\": user_limit,\n            # note: not passing `position` as it already got updated before, if passed\n            \"permission_overwrites\": overwrites_payload,\n            \"rate_limit_per_user\": slowmode_delay,\n            \"default_thread_rate_limit_per_user\": default_thread_slowmode_delay,\n            \"type\": type_payload,\n            \"rtc_region\": rtc_region_payload,\n            \"video_quality_mode\": video_quality_mode_payload,\n            \"default_auto_archive_duration\": default_auto_archive_duration_payload,\n            \"flags\": flags_payload,\n            \"available_tags\": available_tags_payload,\n            \"default_reaction_emoji\": default_reaction_emoji_payload,\n            \"default_sort_order\": default_sort_order_payload,\n            \"default_forum_layout\": default_layout_payload,\n        }\n        options = {k: v for k, v in options.items() if v is not MISSING}\n\n        if options:\n            return await self._state.http.edit_channel(self.id, reason=reason, **options)\n        return None\n\n    def _fill_overwrites(self, data: GuildChannelPayload) -> None:\n        self._overwrites = []\n        everyone_index = 0\n        everyone_id = self.guild.id\n\n        for index, overridden in enumerate(data.get(\"permission_overwrites\", [])):\n            overwrite = _Overwrites(overridden)\n            self._overwrites.append(overwrite)\n\n            if overwrite.type == _Overwrites.MEMBER:\n                continue\n\n            if overwrite.id == everyone_id:\n                # the @everyone role is not guaranteed to be the first one\n                # in the list of permission overwrites, however the permission\n                # resolution code kind of requires that it is the first one in\n                # the list since it is special. So we need the index so we can\n                # swap it to be the first one.\n                everyone_index = index\n\n        # do the swap\n        tmp = self._overwrites\n        if tmp:\n            tmp[everyone_index], tmp[0] = tmp[0], tmp[everyone_index]\n\n    @property\n    def changed_roles(self) -> list[Role]:\n        r\"\"\":class:`list`\\[:class:`.Role`]: Returns a list of roles that have been overridden from\n        their default values in the :attr:`.Guild.roles` attribute.\n        \"\"\"\n        ret: list[Role] = []\n        g = self.guild\n        for overwrite in filter(lambda o: o.is_role(), self._overwrites):\n            role = g.get_role(overwrite.id)\n            if role is None:\n                continue\n\n            role = copy.copy(role)\n            role.permissions.handle_overwrite(overwrite.allow, overwrite.deny)\n            ret.append(role)\n        return ret\n\n    @property\n    def mention(self) -> str:\n        \"\"\":class:`str`: The string that allows you to mention the channel.\"\"\"\n        return f\"<#{self.id}>\"\n\n    @property\n    def created_at(self) -> datetime:\n        \"\"\":class:`datetime.datetime`: Returns the channel's creation time in UTC.\"\"\"\n        return utils.snowflake_time(self.id)\n\n    def overwrites_for(self, obj: Role | User) -> PermissionOverwrite:\n        \"\"\"Returns the channel-specific overwrites for a member or a role.\n\n        Parameters\n        ----------\n        obj: :class:`.Role` | :class:`.abc.User`\n            The role or user denoting\n            whose overwrite to get.\n\n        Returns\n        -------\n        :class:`~disnake.PermissionOverwrite`\n            The permission overwrites for this object.\n        \"\"\"\n        predicate: Callable[[_Overwrites], bool]\n        if isinstance(obj, User):\n            predicate = lambda p: p.is_member()\n        elif isinstance(obj, Role):\n            predicate = lambda p: p.is_role()\n        else:\n            predicate = lambda p: True\n\n        for overwrite in filter(predicate, self._overwrites):\n            if overwrite.id == obj.id:\n                allow = Permissions(overwrite.allow)\n                deny = Permissions(overwrite.deny)\n                return PermissionOverwrite.from_pair(allow, deny)\n\n        return PermissionOverwrite()\n\n    @property\n    def overwrites(self) -> dict[Role | Member, PermissionOverwrite]:\n        r\"\"\"Returns all of the channel's overwrites.\n\n        This is returned as a dictionary where the key contains the target which\n        can be either a :class:`~disnake.Role` or a :class:`~disnake.Member` and the value is the\n        overwrite as a :class:`~disnake.PermissionOverwrite`.\n\n        Returns\n        -------\n        :class:`dict`\\[:class:`~disnake.Role` | :class:`~disnake.Member`, :class:`~disnake.PermissionOverwrite`]\n            The channel's permission overwrites.\n        \"\"\"\n        ret = {}\n        for ow in self._overwrites:\n            allow = Permissions(ow.allow)\n            deny = Permissions(ow.deny)\n            overwrite = PermissionOverwrite.from_pair(allow, deny)\n            target = None\n\n            if ow.is_role():\n                target = self.guild.get_role(ow.id)\n            elif ow.is_member():\n                target = self.guild.get_member(ow.id)\n\n            # TODO: There is potential data loss here in the non-chunked\n            # case, i.e. target is None because get_member returned nothing.\n            # This can be fixed with a slight breaking change to the return type,\n            # i.e. adding disnake.Object to the list of it\n            # However, for now this is an acceptable compromise.\n            if target is not None:\n                ret[target] = overwrite\n        return ret\n\n    @property\n    def category(self) -> CategoryChannel | None:\n        \"\"\":class:`~disnake.CategoryChannel` | :data:`None`: The category this channel belongs to.\n\n        If there is no category then this is :data:`None`.\n        \"\"\"\n        if isinstance(self.guild, Object):\n            return None\n        return self.guild.get_channel(self.category_id)  # pyright: ignore[reportArgumentType, reportReturnType]\n\n    @property\n    def permissions_synced(self) -> bool:\n        \"\"\":class:`bool`: Whether or not the permissions for this channel are synced with the\n        category it belongs to.\n\n        If there is no category then this is ``False``.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self.category_id is None or isinstance(self.guild, Object):\n            return False\n\n        category = self.guild.get_channel(self.category_id)\n        return bool(category and category.overwrites == self.overwrites)\n\n    @property\n    def flags(self) -> ChannelFlags:\n        \"\"\":class:`.ChannelFlags`: The channel flags for this channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return ChannelFlags._from_value(self._flags)\n\n    @property\n    def jump_url(self) -> str:\n        \"\"\"A URL that can be used to jump to this channel.\n\n        .. versionadded:: 2.4\n\n        .. note::\n\n            This exists for all guild channels but may not be usable by the client for all guild channel types.\n        \"\"\"\n        return f\"https://discord.com/channels/{self.guild.id}/{self.id}\"\n\n    def _apply_implict_permissions(self, base: Permissions) -> None:\n        # if you can't send a message in a channel then you can't have certain\n        # permissions as well\n        if not base.send_messages:\n            base.send_tts_messages = False\n            base.send_voice_messages = False\n            base.send_polls = False\n            base.mention_everyone = False\n            base.embed_links = False\n            base.attach_files = False\n\n        # if you can't view a channel then you have no permissions there\n        if not base.view_channel:\n            denied = Permissions.all_channel()\n            base.value &= ~denied.value\n\n    def permissions_for(\n        self,\n        obj: Member | Role,\n        /,\n        *,\n        ignore_timeout: bool = MISSING,\n    ) -> Permissions:\n        \"\"\"Handles permission resolution for the :class:`~disnake.Member`\n        or :class:`~disnake.Role`.\n\n        This function takes into consideration the following cases:\n\n        - Guild owner\n        - Guild roles\n        - Channel overrides\n        - Member overrides\n        - Timeouts\n\n        If a :class:`~disnake.Role` is passed, then it checks the permissions\n        someone with that role would have, which is essentially:\n\n        - The default role permissions\n        - The permissions of the role used as a parameter\n        - The default role permission overwrites\n        - The permission overwrites of the role used as a parameter\n\n        .. note::\n            If the channel originated from an :class:`.Interaction` and\n            the :attr:`.guild` attribute is unavailable, such as with\n            user-installed applications in guilds, this method will not work\n            due to an API limitation.\n            Consider using :attr:`.Interaction.permissions` or :attr:`~.Interaction.app_permissions` instead.\n\n        .. versionchanged:: 2.0\n            The object passed in can now be a role object.\n\n        Parameters\n        ----------\n        obj: :class:`~disnake.Member` | :class:`~disnake.Role`\n            The object to resolve permissions for. This could be either\n            a member or a role. If it's a role then member overwrites\n            are not computed.\n        ignore_timeout: :class:`bool`\n            Whether or not to ignore the user's timeout.\n            Defaults to ``False``.\n\n            .. versionadded:: 2.4\n\n            .. note::\n\n                This only applies to :class:`~disnake.Member` objects.\n\n            .. versionchanged:: 2.6\n\n                The default was changed to ``False``.\n\n        Raises\n        ------\n        TypeError\n            ``ignore_timeout`` is only supported for :class:`~disnake.Member` objects.\n\n        Returns\n        -------\n        :class:`~disnake.Permissions`\n            The resolved permissions for the member or role.\n        \"\"\"\n        # The current cases can be explained as:\n        # Guild owner get all permissions -- no questions asked. Otherwise...\n        # The @everyone role gets the first application.\n        # After that, the applied roles that the user has in the channel\n        # (or otherwise) are then OR'd together.\n        # After the role permissions are resolved, the member permissions\n        # have to take into effect.\n        # After all that is done.. you have to do the following:\n\n        # The operation first takes into consideration the denied\n        # and then the allowed.\n\n        # Timeouted users have only view_channel and read_message_history\n        # if they already have them.\n        if ignore_timeout is not MISSING and isinstance(obj, Role):\n            msg = \"ignore_timeout is only supported for disnake.Member objects\"\n            raise TypeError(msg)\n\n        if ignore_timeout is MISSING:\n            ignore_timeout = False\n\n        if self.guild.owner_id == obj.id:\n            return Permissions.all()\n\n        default = self.guild.default_role\n        base = Permissions(default.permissions.value)\n\n        # Handle the role case first\n        if isinstance(obj, Role):\n            base.value |= obj._permissions\n\n            if base.administrator:\n                return Permissions.all()\n\n            # Apply @everyone allow/deny first since it's special\n            try:\n                maybe_everyone = self._overwrites[0]\n                if maybe_everyone.id == self.guild.id:\n                    base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n            except IndexError:\n                pass\n\n            if obj.is_default():\n                return base\n\n            overwrite = utils.get(self._overwrites, type=_Overwrites.ROLE, id=obj.id)\n            if overwrite is not None:\n                base.handle_overwrite(overwrite.allow, overwrite.deny)\n\n            return base\n\n        roles = obj._roles\n        get_role = self.guild.get_role\n\n        # Apply guild roles that the member has.\n        for role_id in roles:\n            role = get_role(role_id)\n            if role is not None:\n                base.value |= role._permissions\n\n        # Guild-wide Administrator -> True for everything\n        # Bypass all channel-specific overrides\n        if base.administrator:\n            return Permissions.all()\n\n        # Apply @everyone allow/deny first since it's special\n        try:\n            maybe_everyone = self._overwrites[0]\n            if maybe_everyone.id == self.guild.id:\n                base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n                remaining_overwrites = self._overwrites[1:]\n            else:\n                remaining_overwrites = self._overwrites\n        except IndexError:\n            remaining_overwrites = self._overwrites\n\n        denies = 0\n        allows = 0\n\n        # Apply channel specific role permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_role() and roles.has(overwrite.id):\n                denies |= overwrite.deny\n                allows |= overwrite.allow\n\n        base.handle_overwrite(allow=allows, deny=denies)\n\n        # Apply member specific permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_member() and overwrite.id == obj.id:\n                base.handle_overwrite(allow=overwrite.allow, deny=overwrite.deny)\n                break\n\n        # if you have a timeout then you can't have any permissions\n        # except read messages and read message history\n        if not ignore_timeout and obj.current_timeout:\n            allowed = Permissions(view_channel=True, read_message_history=True)\n            base.value &= allowed.value\n\n        return base\n\n    async def delete(self, *, reason: str | None = None) -> None:\n        \"\"\"|coro|\n\n        Deletes the channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to do this.\n\n        Parameters\n        ----------\n        reason: :class:`str` | :data:`None`\n            The reason for deleting this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to delete the channel.\n        NotFound\n            The channel was not found or was already deleted.\n        HTTPException\n            Deleting the channel failed.\n        \"\"\"\n        await self._state.http.delete_channel(self.id, reason=reason)\n\n    @overload\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        overwrite: PermissionOverwrite | None = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_overload_with_permissions\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        reason: str | None = ...,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    async def set_permissions(\n        self,\n        target,\n        *,\n        overwrite: PermissionOverwrite | None = MISSING,\n        reason: str | None = None,\n        **permissions,\n    ) -> None:\n        \"\"\"|coro|\n\n        Sets the channel specific permission overwrites for a target in the\n        channel.\n\n        The ``target`` parameter should either be a :class:`.Member` or a\n        :class:`.Role` that belongs to guild.\n\n        The ``overwrite`` parameter, if given, must either be :data:`None` or\n        :class:`.PermissionOverwrite`. For convenience, you can pass in\n        keyword arguments denoting :class:`.Permissions` attributes. If this is\n        done, then you cannot mix the keyword arguments with the ``overwrite``\n        parameter.\n\n        If the ``overwrite`` parameter is :data:`None`, then the permission\n        overwrites are deleted.\n\n        You must have :attr:`.Permissions.manage_roles` permission to do this.\n\n        .. note::\n\n            This method *replaces* the old overwrites with the ones given.\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` instead of ``InvalidArgument``.\n\n        Examples\n        --------\n        Setting allow and deny: ::\n\n            await message.channel.set_permissions(message.author, view_channel=True,\n                                                                  send_messages=False)\n\n        Deleting overwrites ::\n\n            await channel.set_permissions(member, overwrite=None)\n\n        Using :class:`.PermissionOverwrite` ::\n\n            overwrite = disnake.PermissionOverwrite()\n            overwrite.send_messages = False\n            overwrite.view_channel = True\n            await channel.set_permissions(member, overwrite=overwrite)\n\n        Parameters\n        ----------\n        target: :class:`.Member` | :class:`.Role`\n            The member or role to overwrite permissions for.\n        overwrite: :class:`.PermissionOverwrite` | :data:`None`\n            The permissions to allow and deny to the target, or :data:`None` to\n            delete the overwrite.\n        **permissions\n            A keyword argument list of permissions to set for ease of use.\n            Cannot be mixed with ``overwrite``.\n        reason: :class:`str` | :data:`None`\n            The reason for doing this action. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to edit channel specific permissions.\n        HTTPException\n            Editing channel specific permissions failed.\n        NotFound\n            The role or member being edited is not part of the guild.\n        TypeError\n            ``overwrite`` is invalid,\n            the target type was not :class:`.Role` or :class:`.Member`,\n            both keyword arguments and ``overwrite`` were provided,\n            or invalid permissions were provided as keyword arguments.\n        \"\"\"\n        http = self._state.http\n\n        if isinstance(target, User):\n            perm_type = _Overwrites.MEMBER\n        elif isinstance(target, Role):\n            perm_type = _Overwrites.ROLE\n        else:\n            msg = \"target parameter must be either Member or Role\"\n            raise TypeError(msg)\n\n        if overwrite is MISSING:\n            if len(permissions) == 0:\n                msg = \"No overwrite provided.\"\n                raise TypeError(msg)\n            try:\n                overwrite = PermissionOverwrite(**permissions)\n            except (ValueError, TypeError) as e:\n                msg = \"Invalid permissions given to keyword arguments.\"\n                raise TypeError(msg) from e\n        else:\n            if len(permissions) > 0:\n                msg = \"Cannot mix overwrite and keyword arguments.\"\n                raise TypeError(msg)\n\n        # TODO: wait for event\n\n        if overwrite is None:\n            await http.delete_channel_permissions(self.id, target.id, reason=reason)\n        elif isinstance(overwrite, PermissionOverwrite):\n            (allow, deny) = overwrite.pair()\n            await http.edit_channel_permissions(\n                self.id, target.id, allow.value, deny.value, perm_type, reason=reason\n            )\n        else:\n            msg = \"Invalid overwrite type provided.\"\n            raise TypeError(msg)\n\n    async def _clone_impl(\n        self,\n        base_attrs: dict[str, Any],\n        *,\n        name: str | None = None,\n        category: Snowflake | None = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        reason: str | None = None,\n    ) -> Self:\n        # if the overwrites are MISSING, defaults to the\n        # original permissions of the channel\n        overwrites_payload: list[PermissionOverwritePayload]\n        if overwrites is not MISSING:\n            if not isinstance(overwrites, dict):\n                msg = \"overwrites parameter expects a dict.\"\n                raise TypeError(msg)\n\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": (_Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER),\n                }\n                overwrites_payload.append(payload)\n        else:\n            overwrites_payload = [x._asdict() for x in self._overwrites]\n        base_attrs[\"permission_overwrites\"] = overwrites_payload\n        if category is not MISSING:\n            base_attrs[\"parent_id\"] = category.id if category else None\n        else:\n            # if no category was given don't change the category\n            base_attrs[\"parent_id\"] = self.category_id\n        base_attrs[\"name\"] = name or self.name\n        channel_type = base_attrs.get(\"type\") or self.type.value\n        guild_id = self.guild.id\n        cls = self.__class__\n        data = await self._state.http.create_channel(\n            guild_id, channel_type, reason=reason, **base_attrs\n        )\n        obj = cls(state=self._state, guild=self.guild, data=data)\n\n        # temporarily add it to the cache\n        self.guild._channels[obj.id] = obj  # pyright: ignore[reportArgumentType]\n        return obj\n\n    async def clone(self, *, name: str | None = None, reason: str | None = None) -> Self:\n        \"\"\"|coro|\n\n        Clones this channel. This creates a channel with the same properties\n        as this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. versionadded:: 1.1\n\n        Parameters\n        ----------\n        name: :class:`str` | :data:`None`\n            The name of the new channel. If not provided, defaults to this channel name.\n        reason: :class:`str` | :data:`None`\n            The reason for cloning this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have the proper permissions to create this channel.\n        HTTPException\n            Creating the channel failed.\n\n        Returns\n        -------\n        :class:`.abc.GuildChannel`\n            The channel that was created.\n        \"\"\"\n        raise NotImplementedError\n\n    @overload\n    async def move(\n        self,\n        *,\n        beginning: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        end: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        before: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        after: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    async def move(self, **kwargs: Any) -> None:\n        \"\"\"|coro|\n\n        A rich interface to help move a channel relative to other channels.\n\n        If exact position movement is required, ``edit`` should be used instead.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. note::\n\n            Voice channels will always be sorted below text channels.\n            This is a Discord limitation.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` or :exc:`ValueError` instead of ``InvalidArgument``.\n\n        Parameters\n        ----------\n        beginning: :class:`bool`\n            Whether to move the channel to the beginning of the\n            channel list (or category if given).\n            This is mutually exclusive with ``end``, ``before``, and ``after``.\n        end: :class:`bool`\n            Whether to move the channel to the end of the\n            channel list (or category if given).\n            This is mutually exclusive with ``beginning``, ``before``, and ``after``.\n        before: :class:`.abc.Snowflake`\n            The channel that should be before our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``after``.\n        after: :class:`.abc.Snowflake`\n            The channel that should be after our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``before``.\n        offset: :class:`int`\n            The number of channels to offset the move by. For example,\n            an offset of ``2`` with ``beginning=True`` would move\n            it 2 after the beginning. A positive number moves it below\n            while a negative number moves it above. Note that this\n            number is relative and computed after the ``beginning``,\n            ``end``, ``before``, and ``after`` parameters.\n        category: :class:`.abc.Snowflake` | :data:`None`\n            The category to move this channel under.\n            If :data:`None` is given then it moves it out of the category.\n            This parameter is ignored if moving a category channel.\n        sync_permissions: :class:`bool`\n            Whether to sync the permissions with the category (if given).\n        reason: :class:`str` | :data:`None`\n            The reason for moving this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to move the channel.\n        HTTPException\n            Moving the channel failed.\n        TypeError\n            A bad mix of arguments were passed.\n        ValueError\n            An invalid position was given.\n        \"\"\"\n        if not kwargs:\n            return\n\n        beginning, end = kwargs.get(\"beginning\"), kwargs.get(\"end\")\n        before, after = kwargs.get(\"before\"), kwargs.get(\"after\")\n        offset = kwargs.get(\"offset\", 0)\n        if sum(bool(a) for a in (beginning, end, before, after)) > 1:\n            msg = \"Only one of [before, after, end, beginning] can be used.\"\n            raise TypeError(msg)\n\n        bucket = self._sorting_bucket\n        parent_id = kwargs.get(\"category\", MISSING)\n        if parent_id not in (MISSING, None):\n            parent_id = parent_id.id\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == parent_id\n            ]\n        else:\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == self.category_id\n            ]\n\n        channels.sort(key=lambda c: (c.position, c.id))\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        try:\n            # Try to remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # If we're not there then it's probably due to not being in the category\n            pass\n\n        index = None\n        if beginning:\n            index = 0\n        elif end:\n            index = len(channels)\n        elif before:\n            index = next((i for i, c in enumerate(channels) if c.id == before.id), None)\n        elif after:\n            index = next((i + 1 for i, c in enumerate(channels) if c.id == after.id), None)\n\n        if index is None:\n            msg = \"Could not resolve appropriate move position\"\n            raise ValueError(msg)\n\n        channels.insert(max((index + offset), 0), self)\n        payload: list[ChannelPositionUpdatePayload] = []\n        lock_permissions = kwargs.get(\"sync_permissions\", False)\n        reason = kwargs.get(\"reason\")\n        for index, channel in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": channel.id, \"position\": index}\n            if parent_id is not MISSING and channel.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await self._state.http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def create_invite(\n        self,\n        *,\n        reason: str | None = None,\n        max_age: int = 0,\n        max_uses: int = 0,\n        temporary: bool = False,\n        unique: bool = True,\n        target_type: InviteTarget | None = None,\n        target_user: User | None = None,\n        target_application: Snowflake | PartyType | None = None,\n        guild_scheduled_event: GuildScheduledEvent | None = None,\n    ) -> Invite:\n        \"\"\"|coro|\n\n        Creates an instant invite from a text or voice channel.\n\n        You must have :attr:`.Permissions.create_instant_invite` permission to\n        do this.\n\n        Parameters\n        ----------\n        max_age: :class:`int`\n            How long the invite should last in seconds. If set to ``0``, then the invite\n            doesn't expire. Defaults to ``0``.\n        max_uses: :class:`int`\n            How many uses the invite could be used for. If it's 0 then there\n            are unlimited uses. Defaults to ``0``.\n        temporary: :class:`bool`\n            Whether the invite grants temporary membership\n            (i.e. they get kicked after they disconnect). Defaults to ``False``.\n        unique: :class:`bool`\n            Whether a unique invite URL should be created. Defaults to ``True``.\n            If this is set to ``False`` then it will return a previously created\n            invite.\n        target_type: :class:`.InviteTarget` | :data:`None`\n            The type of target for the voice channel invite, if any.\n\n            .. versionadded:: 2.0\n\n        target_user: :class:`User` | :data:`None`\n            The user whose stream to display for this invite, required if ``target_type`` is :attr:`.InviteTarget.stream`.\n            The user must be streaming in the channel.\n\n            .. versionadded:: 2.0\n\n        target_application: :class:`.Snowflake` | :data:`None`\n            The ID of the embedded application for the invite, required if ``target_type`` is :attr:`.InviteTarget.embedded_application`.\n\n            .. versionadded:: 2.0\n\n            .. versionchanged:: 2.9\n                ``PartyType`` is deprecated, and :class:`.Snowflake` should be used instead.\n\n        guild_scheduled_event: :class:`.GuildScheduledEvent` | :data:`None`\n            The guild scheduled event to include with the invite.\n\n            .. versionadded:: 2.3\n\n        reason: :class:`str` | :data:`None`\n            The reason for creating this invite. Shows up on the audit log.\n\n        Raises\n        ------\n        HTTPException\n            Invite creation failed.\n        NotFound\n            The channel that was passed is a category or an invalid channel.\n\n        Returns\n        -------\n        :class:`.Invite`\n            The newly created invite.\n        \"\"\"\n        if isinstance(target_application, PartyType):\n            utils.warn_deprecated(\n                \"PartyType is deprecated and will be removed in future version\",\n                stacklevel=2,\n            )\n            target_application = Object(target_application.value)\n        data = await self._state.http.create_invite(\n            self.id,\n            reason=reason,\n            max_age=max_age,\n            max_uses=max_uses,\n            temporary=temporary,\n            unique=unique,\n            target_type=try_enum_to_int(target_type),\n            target_user_id=target_user.id if target_user else None,\n            target_application_id=target_application.id if target_application else None,\n        )\n        invite = Invite.from_incomplete(data=data, state=self._state)\n        invite.guild_scheduled_event = guild_scheduled_event\n        return invite\n\n    async def invites(self) -> list[Invite]:\n        r\"\"\"|coro|\n\n        Returns a list of all active instant invites from this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to use this.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to get the information.\n        HTTPException\n            An error occurred while fetching the information.\n\n        Returns\n        -------\n        :class:`list`\\[:class:`.Invite`]\n            The list of invites that are currently active.\n        \"\"\"\n        state = self._state\n        data = await state.http.invites_from_channel(self.id)\n        guild = self.guild\n        return [Invite(state=state, data=invite, channel=self, guild=guild) for invite in data]", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 44081}, "tests/ui/test_action_row.py::175": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow", "disnake", "mock", "pytest"], "enclosing_function": "test_rows_from_message__invalid", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 357}, "tests/test_object.py::20": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Object"], "enclosing_function": "test_compare", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_events.py::39": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Any", "disnake"], "enclosing_function": "test_event", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/test_activity.py::67": {"resolved_imports": ["disnake/__init__.py", "disnake/activity.py"], "used_names": [], "enclosing_function": "test_mp", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_mentions.py::12": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["AllowedMentions"], "enclosing_function": "test_classmethod_none", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_base_core.py::148": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["commands", "warnings"], "enclosing_function": "test_dm_permission", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_flags.py::59": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": [], "enclosing_function": "test_flag_creation", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_onboarding.py::76": {"resolved_imports": ["disnake/__init__.py", "disnake/types/__init__.py", "disnake/types/onboarding.py"], "used_names": ["Onboarding", "onboarding"], "enclosing_function": "test_onboarding", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 3, "n_chars_extracted": 0}, "tests/test_mentions.py::78": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["AllowedMentions", "Object", "pytest"], "enclosing_function": "test_merge", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_abc.py::105": {"resolved_imports": ["disnake/__init__.py", "disnake/abc.py"], "used_names": ["GuildChannel", "disnake"], "enclosing_function": "test_move_only", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\n\n\n# Source: disnake/abc.py\nclass GuildChannel(ABC):\n    \"\"\"An ABC that details the common operations on a Discord guild channel.\n\n    The following classes implement this ABC:\n\n    - :class:`.TextChannel`\n    - :class:`.VoiceChannel`\n    - :class:`.CategoryChannel`\n    - :class:`.StageChannel`\n    - :class:`.ForumChannel`\n    - :class:`.MediaChannel`\n\n    This ABC must also implement :class:`.abc.Snowflake`.\n\n    Attributes\n    ----------\n    name: :class:`str`\n        The channel name.\n    guild: :class:`.Guild`\n        The guild the channel belongs to.\n    position: :class:`int`\n        The position in the channel list. This is a number that starts at 0.\n        e.g. the top channel is position 0.\n    \"\"\"\n\n    __slots__ = ()\n\n    id: int\n    name: str\n    guild: Guild\n    type: ChannelType\n    position: int\n    category_id: int | None\n    _flags: int\n    _state: ConnectionState\n    _overwrites: list[_Overwrites]\n\n    if TYPE_CHECKING:\n\n        def __init__(\n            self, *, state: ConnectionState, guild: Guild, data: Mapping[str, Any]\n        ) -> None: ...\n\n    def __str__(self) -> str:\n        return self.name\n\n    @property\n    def _sorting_bucket(self) -> int:\n        raise NotImplementedError\n\n    def _update(self, guild: Guild, data: dict[str, Any]) -> None:\n        raise NotImplementedError\n\n    async def _move(\n        self,\n        position: int,\n        parent_id: int | None = None,\n        lock_permissions: bool = False,\n        *,\n        reason: str | None,\n    ) -> None:\n        if position < 0:\n            msg = \"Channel position cannot be less than 0.\"\n            raise ValueError(msg)\n\n        http = self._state.http\n        bucket = self._sorting_bucket\n        channels = [c for c in self.guild.channels if c._sorting_bucket == bucket]\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        channels.sort(key=lambda c: c.position)\n\n        try:\n            # remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # not there somehow lol\n            return\n        else:\n            index = next(\n                (i for i, c in enumerate(channels) if c.position >= position), len(channels)\n            )\n            # add ourselves at our designated position\n            channels.insert(index, self)\n\n        payload: list[ChannelPositionUpdatePayload] = []\n        for index, c in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": c.id, \"position\": index}\n            if parent_id is not MISSING and c.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def _edit(\n        self,\n        *,\n        name: str = MISSING,\n        topic: str | None = MISSING,\n        position: int = MISSING,\n        nsfw: bool = MISSING,\n        sync_permissions: bool = MISSING,\n        category: Snowflake | None = MISSING,\n        slowmode_delay: int | None = MISSING,\n        default_thread_slowmode_delay: int | None = MISSING,\n        default_auto_archive_duration: AnyThreadArchiveDuration | None = MISSING,\n        type: ChannelType = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        bitrate: int = MISSING,\n        user_limit: int = MISSING,\n        rtc_region: str | VoiceRegion | None = MISSING,\n        video_quality_mode: VideoQualityMode = MISSING,\n        flags: ChannelFlags = MISSING,\n        available_tags: Sequence[ForumTag] = MISSING,\n        default_reaction: str | Emoji | PartialEmoji | None = MISSING,\n        default_sort_order: ThreadSortOrder | None = MISSING,\n        default_layout: ThreadLayout = MISSING,\n        reason: str | None = None,\n    ) -> ChannelPayload | None:\n        parent_id: int | None\n        if category is not MISSING:\n            # if category is given, it's either `None` (no parent) or a category channel\n            parent_id = category.id if category else None\n        else:\n            # if it's not given, don't change the category\n            parent_id = MISSING\n\n        rtc_region_payload: str | None\n        if rtc_region is not MISSING:\n            rtc_region_payload = str(rtc_region) if rtc_region is not None else None\n        else:\n            rtc_region_payload = MISSING\n\n        video_quality_mode_payload: int | None\n        if video_quality_mode is not MISSING:\n            video_quality_mode_payload = int(video_quality_mode)\n        else:\n            video_quality_mode_payload = MISSING\n\n        default_auto_archive_duration_payload: int | None\n        if default_auto_archive_duration is not MISSING:\n            default_auto_archive_duration_payload = (\n                int(default_auto_archive_duration)\n                if default_auto_archive_duration is not None\n                else default_auto_archive_duration\n            )\n        else:\n            default_auto_archive_duration_payload = MISSING\n\n        lock_permissions: bool = bool(sync_permissions)\n\n        overwrites_payload: list[PermissionOverwritePayload] = MISSING\n\n        if position is not MISSING:\n            await self._move(\n                position, parent_id=parent_id, lock_permissions=lock_permissions, reason=reason\n            )\n            parent_id = MISSING  # no need to change it again in the edit request below\n        elif lock_permissions:\n            if parent_id is not MISSING:\n                p_id = parent_id\n            else:\n                p_id = self.category_id\n\n            if p_id is not None and (parent := self.guild.get_channel(p_id)):\n                overwrites_payload = [c._asdict() for c in parent._overwrites]\n\n        if overwrites not in (MISSING, None):\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": _Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER,\n                }\n                overwrites_payload.append(payload)\n\n        type_payload: int\n        if type is not MISSING:\n            if not isinstance(type, ChannelType):\n                msg = \"type field must be of type ChannelType\"\n                raise TypeError(msg)\n            type_payload = type.value\n        else:\n            type_payload = MISSING\n\n        flags_payload: int\n        if flags is not MISSING:\n            if not isinstance(flags, ChannelFlags):\n                msg = \"flags field must be of type ChannelFlags\"\n                raise TypeError(msg)\n            flags_payload = flags.value\n        else:\n            flags_payload = MISSING\n\n        available_tags_payload: list[PartialForumTagPayload] = MISSING\n        if available_tags is not MISSING:\n            available_tags_payload = [tag.to_dict() for tag in available_tags]\n\n        default_reaction_emoji_payload: DefaultReactionPayload | None = MISSING\n        if default_reaction is not MISSING:\n            if default_reaction is not None:\n                emoji_name, emoji_id = PartialEmoji._emoji_to_name_id(default_reaction)\n                default_reaction_emoji_payload = {\n                    \"emoji_name\": emoji_name,\n                    \"emoji_id\": emoji_id,\n                }\n            else:\n                default_reaction_emoji_payload = None\n\n        default_sort_order_payload: int | None = MISSING\n        if default_sort_order is not MISSING:\n            default_sort_order_payload = (\n                try_enum_to_int(default_sort_order) if default_sort_order is not None else None\n            )\n\n        default_layout_payload: int = MISSING\n        if default_layout is not MISSING:\n            default_layout_payload = try_enum_to_int(default_layout)\n\n        options: dict[str, Any] = {\n            \"name\": name,\n            \"parent_id\": parent_id,\n            \"topic\": topic,\n            \"bitrate\": bitrate,\n            \"nsfw\": nsfw,\n            \"user_limit\": user_limit,\n            # note: not passing `position` as it already got updated before, if passed\n            \"permission_overwrites\": overwrites_payload,\n            \"rate_limit_per_user\": slowmode_delay,\n            \"default_thread_rate_limit_per_user\": default_thread_slowmode_delay,\n            \"type\": type_payload,\n            \"rtc_region\": rtc_region_payload,\n            \"video_quality_mode\": video_quality_mode_payload,\n            \"default_auto_archive_duration\": default_auto_archive_duration_payload,\n            \"flags\": flags_payload,\n            \"available_tags\": available_tags_payload,\n            \"default_reaction_emoji\": default_reaction_emoji_payload,\n            \"default_sort_order\": default_sort_order_payload,\n            \"default_forum_layout\": default_layout_payload,\n        }\n        options = {k: v for k, v in options.items() if v is not MISSING}\n\n        if options:\n            return await self._state.http.edit_channel(self.id, reason=reason, **options)\n        return None\n\n    def _fill_overwrites(self, data: GuildChannelPayload) -> None:\n        self._overwrites = []\n        everyone_index = 0\n        everyone_id = self.guild.id\n\n        for index, overridden in enumerate(data.get(\"permission_overwrites\", [])):\n            overwrite = _Overwrites(overridden)\n            self._overwrites.append(overwrite)\n\n            if overwrite.type == _Overwrites.MEMBER:\n                continue\n\n            if overwrite.id == everyone_id:\n                # the @everyone role is not guaranteed to be the first one\n                # in the list of permission overwrites, however the permission\n                # resolution code kind of requires that it is the first one in\n                # the list since it is special. So we need the index so we can\n                # swap it to be the first one.\n                everyone_index = index\n\n        # do the swap\n        tmp = self._overwrites\n        if tmp:\n            tmp[everyone_index], tmp[0] = tmp[0], tmp[everyone_index]\n\n    @property\n    def changed_roles(self) -> list[Role]:\n        r\"\"\":class:`list`\\[:class:`.Role`]: Returns a list of roles that have been overridden from\n        their default values in the :attr:`.Guild.roles` attribute.\n        \"\"\"\n        ret: list[Role] = []\n        g = self.guild\n        for overwrite in filter(lambda o: o.is_role(), self._overwrites):\n            role = g.get_role(overwrite.id)\n            if role is None:\n                continue\n\n            role = copy.copy(role)\n            role.permissions.handle_overwrite(overwrite.allow, overwrite.deny)\n            ret.append(role)\n        return ret\n\n    @property\n    def mention(self) -> str:\n        \"\"\":class:`str`: The string that allows you to mention the channel.\"\"\"\n        return f\"<#{self.id}>\"\n\n    @property\n    def created_at(self) -> datetime:\n        \"\"\":class:`datetime.datetime`: Returns the channel's creation time in UTC.\"\"\"\n        return utils.snowflake_time(self.id)\n\n    def overwrites_for(self, obj: Role | User) -> PermissionOverwrite:\n        \"\"\"Returns the channel-specific overwrites for a member or a role.\n\n        Parameters\n        ----------\n        obj: :class:`.Role` | :class:`.abc.User`\n            The role or user denoting\n            whose overwrite to get.\n\n        Returns\n        -------\n        :class:`~disnake.PermissionOverwrite`\n            The permission overwrites for this object.\n        \"\"\"\n        predicate: Callable[[_Overwrites], bool]\n        if isinstance(obj, User):\n            predicate = lambda p: p.is_member()\n        elif isinstance(obj, Role):\n            predicate = lambda p: p.is_role()\n        else:\n            predicate = lambda p: True\n\n        for overwrite in filter(predicate, self._overwrites):\n            if overwrite.id == obj.id:\n                allow = Permissions(overwrite.allow)\n                deny = Permissions(overwrite.deny)\n                return PermissionOverwrite.from_pair(allow, deny)\n\n        return PermissionOverwrite()\n\n    @property\n    def overwrites(self) -> dict[Role | Member, PermissionOverwrite]:\n        r\"\"\"Returns all of the channel's overwrites.\n\n        This is returned as a dictionary where the key contains the target which\n        can be either a :class:`~disnake.Role` or a :class:`~disnake.Member` and the value is the\n        overwrite as a :class:`~disnake.PermissionOverwrite`.\n\n        Returns\n        -------\n        :class:`dict`\\[:class:`~disnake.Role` | :class:`~disnake.Member`, :class:`~disnake.PermissionOverwrite`]\n            The channel's permission overwrites.\n        \"\"\"\n        ret = {}\n        for ow in self._overwrites:\n            allow = Permissions(ow.allow)\n            deny = Permissions(ow.deny)\n            overwrite = PermissionOverwrite.from_pair(allow, deny)\n            target = None\n\n            if ow.is_role():\n                target = self.guild.get_role(ow.id)\n            elif ow.is_member():\n                target = self.guild.get_member(ow.id)\n\n            # TODO: There is potential data loss here in the non-chunked\n            # case, i.e. target is None because get_member returned nothing.\n            # This can be fixed with a slight breaking change to the return type,\n            # i.e. adding disnake.Object to the list of it\n            # However, for now this is an acceptable compromise.\n            if target is not None:\n                ret[target] = overwrite\n        return ret\n\n    @property\n    def category(self) -> CategoryChannel | None:\n        \"\"\":class:`~disnake.CategoryChannel` | :data:`None`: The category this channel belongs to.\n\n        If there is no category then this is :data:`None`.\n        \"\"\"\n        if isinstance(self.guild, Object):\n            return None\n        return self.guild.get_channel(self.category_id)  # pyright: ignore[reportArgumentType, reportReturnType]\n\n    @property\n    def permissions_synced(self) -> bool:\n        \"\"\":class:`bool`: Whether or not the permissions for this channel are synced with the\n        category it belongs to.\n\n        If there is no category then this is ``False``.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self.category_id is None or isinstance(self.guild, Object):\n            return False\n\n        category = self.guild.get_channel(self.category_id)\n        return bool(category and category.overwrites == self.overwrites)\n\n    @property\n    def flags(self) -> ChannelFlags:\n        \"\"\":class:`.ChannelFlags`: The channel flags for this channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return ChannelFlags._from_value(self._flags)\n\n    @property\n    def jump_url(self) -> str:\n        \"\"\"A URL that can be used to jump to this channel.\n\n        .. versionadded:: 2.4\n\n        .. note::\n\n            This exists for all guild channels but may not be usable by the client for all guild channel types.\n        \"\"\"\n        return f\"https://discord.com/channels/{self.guild.id}/{self.id}\"\n\n    def _apply_implict_permissions(self, base: Permissions) -> None:\n        # if you can't send a message in a channel then you can't have certain\n        # permissions as well\n        if not base.send_messages:\n            base.send_tts_messages = False\n            base.send_voice_messages = False\n            base.send_polls = False\n            base.mention_everyone = False\n            base.embed_links = False\n            base.attach_files = False\n\n        # if you can't view a channel then you have no permissions there\n        if not base.view_channel:\n            denied = Permissions.all_channel()\n            base.value &= ~denied.value\n\n    def permissions_for(\n        self,\n        obj: Member | Role,\n        /,\n        *,\n        ignore_timeout: bool = MISSING,\n    ) -> Permissions:\n        \"\"\"Handles permission resolution for the :class:`~disnake.Member`\n        or :class:`~disnake.Role`.\n\n        This function takes into consideration the following cases:\n\n        - Guild owner\n        - Guild roles\n        - Channel overrides\n        - Member overrides\n        - Timeouts\n\n        If a :class:`~disnake.Role` is passed, then it checks the permissions\n        someone with that role would have, which is essentially:\n\n        - The default role permissions\n        - The permissions of the role used as a parameter\n        - The default role permission overwrites\n        - The permission overwrites of the role used as a parameter\n\n        .. note::\n            If the channel originated from an :class:`.Interaction` and\n            the :attr:`.guild` attribute is unavailable, such as with\n            user-installed applications in guilds, this method will not work\n            due to an API limitation.\n            Consider using :attr:`.Interaction.permissions` or :attr:`~.Interaction.app_permissions` instead.\n\n        .. versionchanged:: 2.0\n            The object passed in can now be a role object.\n\n        Parameters\n        ----------\n        obj: :class:`~disnake.Member` | :class:`~disnake.Role`\n            The object to resolve permissions for. This could be either\n            a member or a role. If it's a role then member overwrites\n            are not computed.\n        ignore_timeout: :class:`bool`\n            Whether or not to ignore the user's timeout.\n            Defaults to ``False``.\n\n            .. versionadded:: 2.4\n\n            .. note::\n\n                This only applies to :class:`~disnake.Member` objects.\n\n            .. versionchanged:: 2.6\n\n                The default was changed to ``False``.\n\n        Raises\n        ------\n        TypeError\n            ``ignore_timeout`` is only supported for :class:`~disnake.Member` objects.\n\n        Returns\n        -------\n        :class:`~disnake.Permissions`\n            The resolved permissions for the member or role.\n        \"\"\"\n        # The current cases can be explained as:\n        # Guild owner get all permissions -- no questions asked. Otherwise...\n        # The @everyone role gets the first application.\n        # After that, the applied roles that the user has in the channel\n        # (or otherwise) are then OR'd together.\n        # After the role permissions are resolved, the member permissions\n        # have to take into effect.\n        # After all that is done.. you have to do the following:\n\n        # The operation first takes into consideration the denied\n        # and then the allowed.\n\n        # Timeouted users have only view_channel and read_message_history\n        # if they already have them.\n        if ignore_timeout is not MISSING and isinstance(obj, Role):\n            msg = \"ignore_timeout is only supported for disnake.Member objects\"\n            raise TypeError(msg)\n\n        if ignore_timeout is MISSING:\n            ignore_timeout = False\n\n        if self.guild.owner_id == obj.id:\n            return Permissions.all()\n\n        default = self.guild.default_role\n        base = Permissions(default.permissions.value)\n\n        # Handle the role case first\n        if isinstance(obj, Role):\n            base.value |= obj._permissions\n\n            if base.administrator:\n                return Permissions.all()\n\n            # Apply @everyone allow/deny first since it's special\n            try:\n                maybe_everyone = self._overwrites[0]\n                if maybe_everyone.id == self.guild.id:\n                    base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n            except IndexError:\n                pass\n\n            if obj.is_default():\n                return base\n\n            overwrite = utils.get(self._overwrites, type=_Overwrites.ROLE, id=obj.id)\n            if overwrite is not None:\n                base.handle_overwrite(overwrite.allow, overwrite.deny)\n\n            return base\n\n        roles = obj._roles\n        get_role = self.guild.get_role\n\n        # Apply guild roles that the member has.\n        for role_id in roles:\n            role = get_role(role_id)\n            if role is not None:\n                base.value |= role._permissions\n\n        # Guild-wide Administrator -> True for everything\n        # Bypass all channel-specific overrides\n        if base.administrator:\n            return Permissions.all()\n\n        # Apply @everyone allow/deny first since it's special\n        try:\n            maybe_everyone = self._overwrites[0]\n            if maybe_everyone.id == self.guild.id:\n                base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n                remaining_overwrites = self._overwrites[1:]\n            else:\n                remaining_overwrites = self._overwrites\n        except IndexError:\n            remaining_overwrites = self._overwrites\n\n        denies = 0\n        allows = 0\n\n        # Apply channel specific role permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_role() and roles.has(overwrite.id):\n                denies |= overwrite.deny\n                allows |= overwrite.allow\n\n        base.handle_overwrite(allow=allows, deny=denies)\n\n        # Apply member specific permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_member() and overwrite.id == obj.id:\n                base.handle_overwrite(allow=overwrite.allow, deny=overwrite.deny)\n                break\n\n        # if you have a timeout then you can't have any permissions\n        # except read messages and read message history\n        if not ignore_timeout and obj.current_timeout:\n            allowed = Permissions(view_channel=True, read_message_history=True)\n            base.value &= allowed.value\n\n        return base\n\n    async def delete(self, *, reason: str | None = None) -> None:\n        \"\"\"|coro|\n\n        Deletes the channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to do this.\n\n        Parameters\n        ----------\n        reason: :class:`str` | :data:`None`\n            The reason for deleting this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to delete the channel.\n        NotFound\n            The channel was not found or was already deleted.\n        HTTPException\n            Deleting the channel failed.\n        \"\"\"\n        await self._state.http.delete_channel(self.id, reason=reason)\n\n    @overload\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        overwrite: PermissionOverwrite | None = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_overload_with_permissions\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        reason: str | None = ...,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    async def set_permissions(\n        self,\n        target,\n        *,\n        overwrite: PermissionOverwrite | None = MISSING,\n        reason: str | None = None,\n        **permissions,\n    ) -> None:\n        \"\"\"|coro|\n\n        Sets the channel specific permission overwrites for a target in the\n        channel.\n\n        The ``target`` parameter should either be a :class:`.Member` or a\n        :class:`.Role` that belongs to guild.\n\n        The ``overwrite`` parameter, if given, must either be :data:`None` or\n        :class:`.PermissionOverwrite`. For convenience, you can pass in\n        keyword arguments denoting :class:`.Permissions` attributes. If this is\n        done, then you cannot mix the keyword arguments with the ``overwrite``\n        parameter.\n\n        If the ``overwrite`` parameter is :data:`None`, then the permission\n        overwrites are deleted.\n\n        You must have :attr:`.Permissions.manage_roles` permission to do this.\n\n        .. note::\n\n            This method *replaces* the old overwrites with the ones given.\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` instead of ``InvalidArgument``.\n\n        Examples\n        --------\n        Setting allow and deny: ::\n\n            await message.channel.set_permissions(message.author, view_channel=True,\n                                                                  send_messages=False)\n\n        Deleting overwrites ::\n\n            await channel.set_permissions(member, overwrite=None)\n\n        Using :class:`.PermissionOverwrite` ::\n\n            overwrite = disnake.PermissionOverwrite()\n            overwrite.send_messages = False\n            overwrite.view_channel = True\n            await channel.set_permissions(member, overwrite=overwrite)\n\n        Parameters\n        ----------\n        target: :class:`.Member` | :class:`.Role`\n            The member or role to overwrite permissions for.\n        overwrite: :class:`.PermissionOverwrite` | :data:`None`\n            The permissions to allow and deny to the target, or :data:`None` to\n            delete the overwrite.\n        **permissions\n            A keyword argument list of permissions to set for ease of use.\n            Cannot be mixed with ``overwrite``.\n        reason: :class:`str` | :data:`None`\n            The reason for doing this action. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to edit channel specific permissions.\n        HTTPException\n            Editing channel specific permissions failed.\n        NotFound\n            The role or member being edited is not part of the guild.\n        TypeError\n            ``overwrite`` is invalid,\n            the target type was not :class:`.Role` or :class:`.Member`,\n            both keyword arguments and ``overwrite`` were provided,\n            or invalid permissions were provided as keyword arguments.\n        \"\"\"\n        http = self._state.http\n\n        if isinstance(target, User):\n            perm_type = _Overwrites.MEMBER\n        elif isinstance(target, Role):\n            perm_type = _Overwrites.ROLE\n        else:\n            msg = \"target parameter must be either Member or Role\"\n            raise TypeError(msg)\n\n        if overwrite is MISSING:\n            if len(permissions) == 0:\n                msg = \"No overwrite provided.\"\n                raise TypeError(msg)\n            try:\n                overwrite = PermissionOverwrite(**permissions)\n            except (ValueError, TypeError) as e:\n                msg = \"Invalid permissions given to keyword arguments.\"\n                raise TypeError(msg) from e\n        else:\n            if len(permissions) > 0:\n                msg = \"Cannot mix overwrite and keyword arguments.\"\n                raise TypeError(msg)\n\n        # TODO: wait for event\n\n        if overwrite is None:\n            await http.delete_channel_permissions(self.id, target.id, reason=reason)\n        elif isinstance(overwrite, PermissionOverwrite):\n            (allow, deny) = overwrite.pair()\n            await http.edit_channel_permissions(\n                self.id, target.id, allow.value, deny.value, perm_type, reason=reason\n            )\n        else:\n            msg = \"Invalid overwrite type provided.\"\n            raise TypeError(msg)\n\n    async def _clone_impl(\n        self,\n        base_attrs: dict[str, Any],\n        *,\n        name: str | None = None,\n        category: Snowflake | None = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        reason: str | None = None,\n    ) -> Self:\n        # if the overwrites are MISSING, defaults to the\n        # original permissions of the channel\n        overwrites_payload: list[PermissionOverwritePayload]\n        if overwrites is not MISSING:\n            if not isinstance(overwrites, dict):\n                msg = \"overwrites parameter expects a dict.\"\n                raise TypeError(msg)\n\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": (_Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER),\n                }\n                overwrites_payload.append(payload)\n        else:\n            overwrites_payload = [x._asdict() for x in self._overwrites]\n        base_attrs[\"permission_overwrites\"] = overwrites_payload\n        if category is not MISSING:\n            base_attrs[\"parent_id\"] = category.id if category else None\n        else:\n            # if no category was given don't change the category\n            base_attrs[\"parent_id\"] = self.category_id\n        base_attrs[\"name\"] = name or self.name\n        channel_type = base_attrs.get(\"type\") or self.type.value\n        guild_id = self.guild.id\n        cls = self.__class__\n        data = await self._state.http.create_channel(\n            guild_id, channel_type, reason=reason, **base_attrs\n        )\n        obj = cls(state=self._state, guild=self.guild, data=data)\n\n        # temporarily add it to the cache\n        self.guild._channels[obj.id] = obj  # pyright: ignore[reportArgumentType]\n        return obj\n\n    async def clone(self, *, name: str | None = None, reason: str | None = None) -> Self:\n        \"\"\"|coro|\n\n        Clones this channel. This creates a channel with the same properties\n        as this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. versionadded:: 1.1\n\n        Parameters\n        ----------\n        name: :class:`str` | :data:`None`\n            The name of the new channel. If not provided, defaults to this channel name.\n        reason: :class:`str` | :data:`None`\n            The reason for cloning this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have the proper permissions to create this channel.\n        HTTPException\n            Creating the channel failed.\n\n        Returns\n        -------\n        :class:`.abc.GuildChannel`\n            The channel that was created.\n        \"\"\"\n        raise NotImplementedError\n\n    @overload\n    async def move(\n        self,\n        *,\n        beginning: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        end: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        before: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        after: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    async def move(self, **kwargs: Any) -> None:\n        \"\"\"|coro|\n\n        A rich interface to help move a channel relative to other channels.\n\n        If exact position movement is required, ``edit`` should be used instead.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. note::\n\n            Voice channels will always be sorted below text channels.\n            This is a Discord limitation.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` or :exc:`ValueError` instead of ``InvalidArgument``.\n\n        Parameters\n        ----------\n        beginning: :class:`bool`\n            Whether to move the channel to the beginning of the\n            channel list (or category if given).\n            This is mutually exclusive with ``end``, ``before``, and ``after``.\n        end: :class:`bool`\n            Whether to move the channel to the end of the\n            channel list (or category if given).\n            This is mutually exclusive with ``beginning``, ``before``, and ``after``.\n        before: :class:`.abc.Snowflake`\n            The channel that should be before our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``after``.\n        after: :class:`.abc.Snowflake`\n            The channel that should be after our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``before``.\n        offset: :class:`int`\n            The number of channels to offset the move by. For example,\n            an offset of ``2`` with ``beginning=True`` would move\n            it 2 after the beginning. A positive number moves it below\n            while a negative number moves it above. Note that this\n            number is relative and computed after the ``beginning``,\n            ``end``, ``before``, and ``after`` parameters.\n        category: :class:`.abc.Snowflake` | :data:`None`\n            The category to move this channel under.\n            If :data:`None` is given then it moves it out of the category.\n            This parameter is ignored if moving a category channel.\n        sync_permissions: :class:`bool`\n            Whether to sync the permissions with the category (if given).\n        reason: :class:`str` | :data:`None`\n            The reason for moving this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to move the channel.\n        HTTPException\n            Moving the channel failed.\n        TypeError\n            A bad mix of arguments were passed.\n        ValueError\n            An invalid position was given.\n        \"\"\"\n        if not kwargs:\n            return\n\n        beginning, end = kwargs.get(\"beginning\"), kwargs.get(\"end\")\n        before, after = kwargs.get(\"before\"), kwargs.get(\"after\")\n        offset = kwargs.get(\"offset\", 0)\n        if sum(bool(a) for a in (beginning, end, before, after)) > 1:\n            msg = \"Only one of [before, after, end, beginning] can be used.\"\n            raise TypeError(msg)\n\n        bucket = self._sorting_bucket\n        parent_id = kwargs.get(\"category\", MISSING)\n        if parent_id not in (MISSING, None):\n            parent_id = parent_id.id\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == parent_id\n            ]\n        else:\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == self.category_id\n            ]\n\n        channels.sort(key=lambda c: (c.position, c.id))\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        try:\n            # Try to remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # If we're not there then it's probably due to not being in the category\n            pass\n\n        index = None\n        if beginning:\n            index = 0\n        elif end:\n            index = len(channels)\n        elif before:\n            index = next((i for i, c in enumerate(channels) if c.id == before.id), None)\n        elif after:\n            index = next((i + 1 for i, c in enumerate(channels) if c.id == after.id), None)\n\n        if index is None:\n            msg = \"Could not resolve appropriate move position\"\n            raise ValueError(msg)\n\n        channels.insert(max((index + offset), 0), self)\n        payload: list[ChannelPositionUpdatePayload] = []\n        lock_permissions = kwargs.get(\"sync_permissions\", False)\n        reason = kwargs.get(\"reason\")\n        for index, channel in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": channel.id, \"position\": index}\n            if parent_id is not MISSING and channel.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await self._state.http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def create_invite(\n        self,\n        *,\n        reason: str | None = None,\n        max_age: int = 0,\n        max_uses: int = 0,\n        temporary: bool = False,\n        unique: bool = True,\n        target_type: InviteTarget | None = None,\n        target_user: User | None = None,\n        target_application: Snowflake | PartyType | None = None,\n        guild_scheduled_event: GuildScheduledEvent | None = None,\n    ) -> Invite:\n        \"\"\"|coro|\n\n        Creates an instant invite from a text or voice channel.\n\n        You must have :attr:`.Permissions.create_instant_invite` permission to\n        do this.\n\n        Parameters\n        ----------\n        max_age: :class:`int`\n            How long the invite should last in seconds. If set to ``0``, then the invite\n            doesn't expire. Defaults to ``0``.\n        max_uses: :class:`int`\n            How many uses the invite could be used for. If it's 0 then there\n            are unlimited uses. Defaults to ``0``.\n        temporary: :class:`bool`\n            Whether the invite grants temporary membership\n            (i.e. they get kicked after they disconnect). Defaults to ``False``.\n        unique: :class:`bool`\n            Whether a unique invite URL should be created. Defaults to ``True``.\n            If this is set to ``False`` then it will return a previously created\n            invite.\n        target_type: :class:`.InviteTarget` | :data:`None`\n            The type of target for the voice channel invite, if any.\n\n            .. versionadded:: 2.0\n\n        target_user: :class:`User` | :data:`None`\n            The user whose stream to display for this invite, required if ``target_type`` is :attr:`.InviteTarget.stream`.\n            The user must be streaming in the channel.\n\n            .. versionadded:: 2.0\n\n        target_application: :class:`.Snowflake` | :data:`None`\n            The ID of the embedded application for the invite, required if ``target_type`` is :attr:`.InviteTarget.embedded_application`.\n\n            .. versionadded:: 2.0\n\n            .. versionchanged:: 2.9\n                ``PartyType`` is deprecated, and :class:`.Snowflake` should be used instead.\n\n        guild_scheduled_event: :class:`.GuildScheduledEvent` | :data:`None`\n            The guild scheduled event to include with the invite.\n\n            .. versionadded:: 2.3\n\n        reason: :class:`str` | :data:`None`\n            The reason for creating this invite. Shows up on the audit log.\n\n        Raises\n        ------\n        HTTPException\n            Invite creation failed.\n        NotFound\n            The channel that was passed is a category or an invalid channel.\n\n        Returns\n        -------\n        :class:`.Invite`\n            The newly created invite.\n        \"\"\"\n        if isinstance(target_application, PartyType):\n            utils.warn_deprecated(\n                \"PartyType is deprecated and will be removed in future version\",\n                stacklevel=2,\n            )\n            target_application = Object(target_application.value)\n        data = await self._state.http.create_invite(\n            self.id,\n            reason=reason,\n            max_age=max_age,\n            max_uses=max_uses,\n            temporary=temporary,\n            unique=unique,\n            target_type=try_enum_to_int(target_type),\n            target_user_id=target_user.id if target_user else None,\n            target_application_id=target_application.id if target_application else None,\n        )\n        invite = Invite.from_incomplete(data=data, state=self._state)\n        invite.guild_scheduled_event = guild_scheduled_event\n        return invite\n\n    async def invites(self) -> list[Invite]:\n        r\"\"\"|coro|\n\n        Returns a list of all active instant invites from this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to use this.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to get the information.\n        HTTPException\n            An error occurred while fetching the information.\n\n        Returns\n        -------\n        :class:`list`\\[:class:`.Invite`]\n            The list of invites that are currently active.\n        \"\"\"\n        state = self._state\n        data = await state.http.invites_from_channel(self.id)\n        guild = self.guild\n        return [Invite(state=state, data=invite, channel=self, guild=guild) for invite in data]", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 44081}, "tests/ext/commands/test_base_core.py::89": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Permissions", "commands"], "enclosing_function": "test_attrs", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_onboarding.py::73": {"resolved_imports": ["disnake/__init__.py", "disnake/types/__init__.py", "disnake/types/onboarding.py"], "used_names": ["Onboarding", "onboarding"], "enclosing_function": "test_onboarding", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 3, "n_chars_extracted": 0}, "tests/ext/commands/test_slash_core.py::36": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_qualified_name", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_utils.py::397": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["asyncio", "pytest", "utils"], "enclosing_function": "test_sane_wait_for", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_params.py::215": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["commands", "disnake", "pytest"], "enclosing_function": "test_optional", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 7, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/ui/test_action_row.py::174": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow", "disnake", "mock", "pytest"], "enclosing_function": "test_rows_from_message__invalid", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 357}, "tests/test_permissions.py::20": {"resolved_imports": ["disnake/permissions.py"], "used_names": ["Permissions"], "enclosing_function": "test_init_permissions_keyword_arguments_with_aliases", "extracted_code": "# Source: disnake/permissions.py\nclass Permissions(BaseFlags):\n    \"\"\"Wraps up the Discord permission value.\n\n    The properties provided are two way. You can set and retrieve individual\n    bits using the properties as if they were regular bools. This allows\n    you to edit permissions.\n\n    To construct an object you can pass keyword arguments denoting the permissions\n    to enable or disable.\n    Arguments are applied in order, which notably also means that supplying a flag\n    and its alias will make whatever comes last overwrite the first one; as an example,\n    ``Permissions(external_emojis=True, use_external_emojis=False)`` and\n    ``Permissions(use_external_emojis=True, external_emojis=False)``\n    both result in the same permissions value (``0``).\n\n    .. versionchanged:: 1.3\n        You can now use keyword arguments to initialize :class:`Permissions`\n        similar to :meth:`update`.\n\n    .. collapse:: operations\n\n        .. describe:: x == y\n\n            Checks if two permissions are equal.\n        .. describe:: x != y\n\n            Checks if two permissions are not equal.\n        .. describe:: x <= y\n\n            Checks if a permission is a subset of another permission.\n        .. describe:: x >= y\n\n            Checks if a permission is a superset of another permission.\n        .. describe:: x < y\n\n            Checks if a permission is a strict subset of another permission.\n        .. describe:: x > y\n\n            Checks if a permission is a strict superset of another permission.\n        .. describe:: x | y, x |= y\n\n            Returns a new Permissions instance with all enabled permissions from both x and y.\n            (Using ``|=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: x & y, x &= y\n\n            Returns a new Permissions instance with only permissions enabled on both x and y.\n            (Using ``&=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: x ^ y, x ^= y\n\n            Returns a new Permissions instance with only permissions enabled on one of x or y, but not both.\n            (Using ``^=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: ~x\n\n            Returns a new Permissions instance with all permissions from x inverted.\n\n            .. versionadded:: 2.6\n        .. describe:: hash(x)\n\n               Return the permission's hash.\n        .. describe:: iter(x)\n\n               Returns an iterator of ``(perm, value)`` pairs. This allows it\n               to be, for example, constructed as a dict or a list of pairs.\n               Note that aliases are not shown.\n\n\n        Additionally supported are a few operations on class attributes.\n\n        .. describe:: Permissions.y | Permissions.z, Permissions(y=True) | Permissions.z\n\n            Returns a Permissions instance with all provided permissions enabled.\n\n            .. versionadded:: 2.6\n        .. describe:: ~Permissions.y\n\n            Returns a Permissions instance with all permissions except ``y`` inverted from their default value.\n\n            .. versionadded:: 2.6\n\n    Attributes\n    ----------\n    value: :class:`int`\n        The raw value. This value is a bit array field of a 53-bit integer\n        representing the currently available permissions. You should query\n        permissions via the properties rather than using this raw value.\n    \"\"\"\n\n    __slots__ = ()\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        permissions: int = 0,\n        *,\n        add_reactions: bool = ...,\n        administrator: bool = ...,\n        attach_files: bool = ...,\n        ban_members: bool = ...,\n        bypass_slowmode: bool = ...,\n        change_nickname: bool = ...,\n        connect: bool = ...,\n        create_events: bool = ...,\n        create_forum_threads: bool = ...,\n        create_guild_expressions: bool = ...,\n        create_instant_invite: bool = ...,\n        create_private_threads: bool = ...,\n        create_public_threads: bool = ...,\n        deafen_members: bool = ...,\n        embed_links: bool = ...,\n        external_emojis: bool = ...,\n        external_stickers: bool = ...,\n        kick_members: bool = ...,\n        manage_channels: bool = ...,\n        manage_emojis: bool = ...,\n        manage_emojis_and_stickers: bool = ...,\n        manage_events: bool = ...,\n        manage_guild: bool = ...,\n        manage_guild_expressions: bool = ...,\n        manage_messages: bool = ...,\n        manage_nicknames: bool = ...,\n        manage_permissions: bool = ...,\n        manage_roles: bool = ...,\n        manage_threads: bool = ...,\n        manage_webhooks: bool = ...,\n        mention_everyone: bool = ...,\n        moderate_members: bool = ...,\n        move_members: bool = ...,\n        mute_members: bool = ...,\n        pin_messages: bool = ...,\n        priority_speaker: bool = ...,\n        read_message_history: bool = ...,\n        read_messages: bool = ...,\n        request_to_speak: bool = ...,\n        send_messages: bool = ...,\n        send_messages_in_threads: bool = ...,\n        send_polls: bool = ...,\n        send_tts_messages: bool = ...,\n        send_voice_messages: bool = ...,\n        speak: bool = ...,\n        start_embedded_activities: bool = ...,\n        stream: bool = ...,\n        use_application_commands: bool = ...,\n        use_embedded_activities: bool = ...,\n        use_external_apps: bool = ...,\n        use_external_emojis: bool = ...,\n        use_external_sounds: bool = ...,\n        use_external_stickers: bool = ...,\n        use_slash_commands: bool = ...,\n        use_soundboard: bool = ...,\n        use_voice_activation: bool = ...,\n        view_audit_log: bool = ...,\n        view_channel: bool = ...,\n        view_creator_monetization_analytics: bool = ...,\n        view_guild_insights: bool = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        permissions: int = 0,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def __init__(self, permissions: int = 0, **kwargs: bool) -> None:\n        if not isinstance(permissions, int):\n            msg = f\"Expected int parameter, received {permissions.__class__.__name__} instead.\"\n            raise TypeError(msg)\n\n        self.value = permissions\n        for key, value in kwargs.items():\n            if key not in self.VALID_FLAGS:\n                msg = f\"{key!r} is not a valid permission name.\"\n                raise TypeError(msg)\n            setattr(self, key, value)\n\n    def is_subset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if self has the same or fewer permissions as other.\"\"\"\n        if isinstance(other, Permissions):\n            return (self.value & other.value) == self.value\n        else:\n            msg = f\"cannot compare {self.__class__.__name__} with {other.__class__.__name__}\"\n            raise TypeError(msg)\n\n    def is_superset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if self has the same or more permissions as other.\"\"\"\n        if isinstance(other, Permissions):\n            return (self.value | other.value) == self.value\n        else:\n            msg = f\"cannot compare {self.__class__.__name__} with {other.__class__.__name__}\"\n            raise TypeError(msg)\n\n    def is_strict_subset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if the permissions on self are a strict subset of those on other.\"\"\"\n        return self.is_subset(other) and self != other\n\n    def is_strict_superset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if the permissions on self are a strict superset of those on other.\"\"\"\n        return self.is_superset(other) and self != other\n\n    # the parent uses `Self` for the `other` typehint but we use `Permissions` here for backwards compat.\n    __le__ = is_subset\n    __ge__ = is_superset\n    __lt__ = is_strict_subset\n    __gt__ = is_strict_superset\n\n    @classmethod\n    @cached_creation\n    def none(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        permissions set to ``False``.\n        \"\"\"\n        return cls(0)\n\n    @classmethod\n    @cached_creation\n    def all(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        permissions set to ``True``.\n        \"\"\"\n        return cls(**dict.fromkeys(cls.VALID_FLAGS.keys(), True))\n\n    @classmethod\n    @cached_creation\n    def all_channel(cls) -> Self:\n        \"\"\"A :class:`Permissions` with all channel-specific permissions set to\n        ``True`` and the guild-specific ones set to ``False``. The guild-specific\n        permissions are currently:\n\n        - :attr:`create_guild_expressions`\n        - :attr:`manage_guild_expressions`\n        - :attr:`view_audit_log`\n        - :attr:`view_guild_insights`\n        - :attr:`view_creator_monetization_analytics`\n        - :attr:`manage_guild`\n        - :attr:`change_nickname`\n        - :attr:`manage_nicknames`\n        - :attr:`kick_members`\n        - :attr:`ban_members`\n        - :attr:`moderate_members`\n        - :attr:`administrator`\n\n        .. versionchanged:: 1.7\n           Added :attr:`stream`, :attr:`priority_speaker` and :attr:`use_slash_commands` permissions.\n\n        .. versionchanged:: 2.0\n           Added :attr:`create_public_threads`, :attr:`create_private_threads`, :attr:`manage_threads`,\n           :attr:`use_external_stickers`, :attr:`send_messages_in_threads` and\n           :attr:`request_to_speak` permissions.\n\n        .. versionchanged:: 2.3\n            Added :attr:`use_embedded_activities` permission.\n\n        .. versionchanged:: 2.9\n            Added :attr:`use_soundboard` and :attr:`send_voice_messages` permissions.\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_events` permission.\n        \"\"\"\n        instance = cls.all()\n        instance.update(\n            administrator=False,\n            ban_members=False,\n            change_nickname=False,\n            create_guild_expressions=False,\n            kick_members=False,\n            manage_guild=False,\n            manage_guild_expressions=False,\n            manage_nicknames=False,\n            moderate_members=False,\n            view_audit_log=False,\n            view_guild_insights=False,\n            view_creator_monetization_analytics=False,\n        )\n        return instance\n\n    @classmethod\n    @cached_creation\n    def general(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"General\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 1.7\n           Permission :attr:`read_messages` is now included in the general permissions, but\n           permissions :attr:`administrator`, :attr:`create_instant_invite`, :attr:`kick_members`,\n           :attr:`ban_members`, :attr:`change_nickname` and :attr:`manage_nicknames` are\n           no longer part of the general permissions.\n\n        .. versionchanged:: 2.9\n            Added :attr:`view_creator_monetization_analytics` permission.\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_guild_expressions` permission.\n        \"\"\"\n        return cls(\n            view_channel=True,\n            manage_channels=True,\n            manage_roles=True,\n            create_guild_expressions=True,\n            manage_guild_expressions=True,\n            view_audit_log=True,\n            view_guild_insights=True,\n            view_creator_monetization_analytics=True,\n            manage_webhooks=True,\n            manage_guild=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def membership(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Membership\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.3\n            Added :attr:`moderate_members` permission.\n        \"\"\"\n        return cls(\n            create_instant_invite=True,\n            change_nickname=True,\n            manage_nicknames=True,\n            kick_members=True,\n            ban_members=True,\n            moderate_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def text(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Text\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 1.7\n           Permission :attr:`read_messages` is no longer part of the text permissions.\n           Added :attr:`use_slash_commands` permission.\n\n        .. versionchanged:: 2.0\n           Added :attr:`create_public_threads`, :attr:`create_private_threads`, :attr:`manage_threads`,\n           :attr:`send_messages_in_threads` and :attr:`use_external_stickers` permissions.\n\n        .. versionchanged:: 2.9\n            Added :attr:`send_voice_messages` permission.\n\n        .. versionchanged:: 2.10\n            Moved :attr:`use_application_commands` permission to :attr:`apps`.\n            Added :attr:`send_polls` permission.\n\n        .. versionchanged:: 2.11\n            Added :attr:`pin_messages` permission.\n\n        .. versionchanged:: 2.12\n            Added :attr:`bypass_slowmode` permission.\n        \"\"\"\n        return cls(\n            send_messages=True,\n            send_messages_in_threads=True,\n            create_public_threads=True,\n            create_private_threads=True,\n            embed_links=True,\n            attach_files=True,\n            add_reactions=True,\n            use_external_emojis=True,\n            use_external_stickers=True,\n            mention_everyone=True,\n            manage_messages=True,\n            manage_threads=True,\n            read_message_history=True,\n            send_tts_messages=True,\n            send_voice_messages=True,\n            pin_messages=True,\n            send_polls=True,\n            bypass_slowmode=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def voice(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Voice\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 2.3\n            Added :attr:`use_embedded_activities` permission.\n\n        .. versionchanged:: 2.9\n            Added :attr:`use_soundboard` and :attr:`use_external_sounds` permissions.\n\n        .. versionchanged:: 2.10\n            Moved :attr:`use_embedded_activities` permission to :attr:`apps`.\n        \"\"\"\n        return cls(\n            connect=True,\n            speak=True,\n            stream=True,\n            use_soundboard=True,\n            use_external_sounds=True,\n            use_voice_activation=True,\n            priority_speaker=True,\n            mute_members=True,\n            deafen_members=True,\n            move_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def stage(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Stage Channel\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            request_to_speak=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def stage_moderator(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Stage Moderator\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            manage_channels=True,\n            mute_members=True,\n            move_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def apps(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Apps\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return cls(\n            use_application_commands=True,\n            use_embedded_activities=True,\n            use_external_apps=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def events(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Events\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 2.4\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_events` permission.\n        \"\"\"\n        return cls(\n            create_events=True,\n            manage_events=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def advanced(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Advanced\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            administrator=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def private_channel(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with the\n        best representation of a PrivateChannel's permissions.\n\n        This exists to maintain compatibility with other channel types.\n\n        This is equivalent to :meth:`Permissions.text` with :attr:`~Permissions.view_channel` with the following set to False:\n\n        - :attr:`~Permissions.send_tts_messages`: You cannot send TTS messages in a DM.\n        - :attr:`~Permissions.manage_messages`: You cannot delete others' messages in a DM.\n        - :attr:`~Permissions.manage_threads`: You cannot manage threads in a DM.\n        - :attr:`~Permissions.send_messages_in_threads`: You cannot make threads in a DM.\n        - :attr:`~Permissions.create_public_threads`: You cannot make public threads in a DM.\n        - :attr:`~Permissions.create_private_threads`: You cannot make private threads in a DM.\n        - :attr:`~Permissions.bypass_slowmode`: You cannot enable slowmode in a DM.\n\n        .. versionadded:: 2.4\n        \"\"\"\n        base = cls.text()\n        base.read_messages = True\n        base.send_tts_messages = False\n        base.manage_messages = False\n        base.manage_threads = False\n        base.send_messages_in_threads = False\n        base.create_public_threads = False\n        base.create_private_threads = False\n        base.bypass_slowmode = False\n        return base\n\n    @overload\n    @_generated\n    def update(\n        self,\n        *,\n        add_reactions: bool = ...,\n        administrator: bool = ...,\n        attach_files: bool = ...,\n        ban_members: bool = ...,\n        bypass_slowmode: bool = ...,\n        change_nickname: bool = ...,\n        connect: bool = ...,\n        create_events: bool = ...,\n        create_forum_threads: bool = ...,\n        create_guild_expressions: bool = ...,\n        create_instant_invite: bool = ...,\n        create_private_threads: bool = ...,\n        create_public_threads: bool = ...,\n        deafen_members: bool = ...,\n        embed_links: bool = ...,\n        external_emojis: bool = ...,\n        external_stickers: bool = ...,\n        kick_members: bool = ...,\n        manage_channels: bool = ...,\n        manage_emojis: bool = ...,\n        manage_emojis_and_stickers: bool = ...,\n        manage_events: bool = ...,\n        manage_guild: bool = ...,\n        manage_guild_expressions: bool = ...,\n        manage_messages: bool = ...,\n        manage_nicknames: bool = ...,\n        manage_permissions: bool = ...,\n        manage_roles: bool = ...,\n        manage_threads: bool = ...,\n        manage_webhooks: bool = ...,\n        mention_everyone: bool = ...,\n        moderate_members: bool = ...,\n        move_members: bool = ...,\n        mute_members: bool = ...,\n        pin_messages: bool = ...,\n        priority_speaker: bool = ...,\n        read_message_history: bool = ...,\n        read_messages: bool = ...,\n        request_to_speak: bool = ...,\n        send_messages: bool = ...,\n        send_messages_in_threads: bool = ...,\n        send_polls: bool = ...,\n        send_tts_messages: bool = ...,\n        send_voice_messages: bool = ...,\n        speak: bool = ...,\n        start_embedded_activities: bool = ...,\n        stream: bool = ...,\n        use_application_commands: bool = ...,\n        use_embedded_activities: bool = ...,\n        use_external_apps: bool = ...,\n        use_external_emojis: bool = ...,\n        use_external_sounds: bool = ...,\n        use_external_stickers: bool = ...,\n        use_slash_commands: bool = ...,\n        use_soundboard: bool = ...,\n        use_voice_activation: bool = ...,\n        view_audit_log: bool = ...,\n        view_channel: bool = ...,\n        view_creator_monetization_analytics: bool = ...,\n        view_guild_insights: bool = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def update(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def update(self, **kwargs: bool) -> None:\n        \"\"\"Bulk updates this permission object.\n\n        Allows you to set multiple attributes by using keyword\n        arguments. The names must be equivalent to the properties\n        listed. Extraneous key/value pairs will be silently ignored.\n\n        Arguments are applied in order, similar to the constructor.\n\n        Parameters\n        ----------\n        **kwargs\n            A list of key/value pairs to bulk update permissions with.\n        \"\"\"\n        for key, value in kwargs.items():\n            if key in self.VALID_FLAGS:\n                setattr(self, key, value)\n\n    def handle_overwrite(self, allow: int, deny: int) -> None:\n        # Basically this is what's happening here.\n        # We have an original bit array, e.g. 1010\n        # Then we have another bit array that is 'denied', e.g. 1111\n        # And then we have the last one which is 'allowed', e.g. 0101\n        # We want original OP denied to end up resulting in\n        # whatever is in denied to be set to 0.\n        # So 1010 OP 1111 -> 0000\n        # Then we take this value and look at the allowed values.\n        # And whatever is allowed is set to 1.\n        # So 0000 OP2 0101 -> 0101\n        # The OP is base  & ~denied.\n        # The OP2 is base | allowed.\n        self.value = (self.value & ~deny) | allow\n\n    @flag_value\n    def create_instant_invite(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if the user can create instant invites.\"\"\"\n        return 1 << 0\n\n    @flag_value\n    def kick_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if the user can kick users from the guild.\"\"\"\n        return 1 << 1\n\n    @flag_value\n    def ban_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can ban users from the guild.\"\"\"\n        return 1 << 2\n\n    @flag_value\n    def administrator(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user is an administrator. This role overrides all other permissions.\n\n        This also bypasses all channel-specific overrides.\n        \"\"\"\n        return 1 << 3\n\n    @flag_value\n    def manage_channels(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit, delete, or create channels in the guild.\n\n        This also corresponds to the \"Manage Channel\" channel-specific override.\n        \"\"\"\n        return 1 << 4\n\n    @flag_value\n    def manage_guild(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit guild properties.\"\"\"\n        return 1 << 5\n\n    @flag_value\n    def add_reactions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can add reactions to messages.\"\"\"\n        return 1 << 6\n\n    @flag_value\n    def view_audit_log(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view the guild's audit log.\"\"\"\n        return 1 << 7\n\n    @flag_value\n    def priority_speaker(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can be more easily heard while talking.\"\"\"\n        return 1 << 8\n\n    @flag_value\n    def stream(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can stream in a voice channel.\"\"\"\n        return 1 << 9\n\n    @flag_value\n    def view_channel(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view all or specific channels.\n\n        .. versionadded:: 1.3\n\n        .. versionchanged:: 2.4\n            :attr:`~Permissions.read_messages` is now an alias of :attr:`~Permissions.view_channel`.\n        \"\"\"\n        return 1 << 10\n\n    @make_permission_alias(\"view_channel\")\n    def read_messages(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`view_channel`.\"\"\"\n        return 1 << 10\n\n    @flag_value\n    def send_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send messages from all or specific text channels\n        and create threads in forum/media channels.\n        \"\"\"\n        return 1 << 11\n\n    @make_permission_alias(\"send_messages\")\n    def create_forum_threads(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`send_messages`.\n\n        .. versionadded:: 2.5\n        \"\"\"\n        return 1 << 11\n\n    @flag_value\n    def send_tts_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send TTS messages from all or specific text channels.\"\"\"\n        return 1 << 12\n\n    @flag_value\n    def manage_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can delete messages in a text channel.\n\n        .. note::\n\n            Note that there are currently no ways to edit other people's messages.\n        \"\"\"\n        return 1 << 13\n\n    @flag_value\n    def embed_links(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's messages will automatically be embedded by Discord.\"\"\"\n        return 1 << 14\n\n    @flag_value\n    def attach_files(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send files in their messages.\"\"\"\n        return 1 << 15\n\n    @flag_value\n    def read_message_history(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can read a text channel's previous messages.\"\"\"\n        return 1 << 16\n\n    @flag_value\n    def mention_everyone(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's @everyone or @here will mention everyone in the text channel.\"\"\"\n        return 1 << 17\n\n    @flag_value\n    def external_emojis(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use emojis from other guilds.\"\"\"\n        return 1 << 18\n\n    @make_permission_alias(\"external_emojis\")\n    def use_external_emojis(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`external_emojis`.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 18\n\n    @flag_value\n    def view_guild_insights(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view the guild's insights.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 19\n\n    @flag_value\n    def connect(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can connect to a voice channel.\"\"\"\n        return 1 << 20\n\n    @flag_value\n    def speak(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can speak in a voice channel.\"\"\"\n        return 1 << 21\n\n    @flag_value\n    def mute_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can mute other users.\"\"\"\n        return 1 << 22\n\n    @flag_value\n    def deafen_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can deafen other users.\"\"\"\n        return 1 << 23\n\n    @flag_value\n    def move_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can move users between other voice channels.\"\"\"\n        return 1 << 24\n\n    @flag_value\n    def use_voice_activation(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use voice activation in voice channels.\"\"\"\n        return 1 << 25\n\n    @flag_value\n    def change_nickname(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can change their nickname in the guild.\"\"\"\n        return 1 << 26\n\n    @flag_value\n    def manage_nicknames(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can change other user's nickname in the guild.\"\"\"\n        return 1 << 27\n\n    @flag_value\n    def manage_roles(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create or edit roles less than their role's position.\n\n        This also corresponds to the \"Manage Permissions\" channel-specific override.\n        \"\"\"\n        return 1 << 28\n\n    @make_permission_alias(\"manage_roles\")\n    def manage_permissions(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_roles`.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 28\n\n    @flag_value\n    def manage_webhooks(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create, edit, or delete webhooks.\"\"\"\n        return 1 << 29\n\n    @flag_value\n    def manage_guild_expressions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit or delete\n        emojis, stickers, and soundboard sounds created by all users.\n\n        See also :attr:`create_guild_expressions`.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 30\n\n    @make_permission_alias(\"manage_guild_expressions\")\n    def manage_emojis(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_guild_expressions`.\"\"\"\n        return 1 << 30\n\n    @make_permission_alias(\"manage_guild_expressions\")\n    def manage_emojis_and_stickers(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_guild_expressions`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 30\n\n    @flag_value\n    def use_application_commands(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use application commands.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return 1 << 31\n\n    @make_permission_alias(\"use_application_commands\")\n    def use_slash_commands(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`use_application_commands`.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Became an alias for :attr:`use_application_commands`.\n        \"\"\"\n        return 1 << 31\n\n    @flag_value\n    def request_to_speak(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can request to speak in a stage channel.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return 1 << 32\n\n    @flag_value\n    def manage_events(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit or delete guild scheduled events\n        created by all users.\n\n        See also :attr:`create_events`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 33\n\n    @flag_value\n    def manage_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can manage threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 34\n\n    @flag_value\n    def create_public_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create public threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 35\n\n    @flag_value\n    def create_private_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create private threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 36\n\n    @flag_value\n    def external_stickers(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use stickers from other guilds.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 37\n\n    @make_permission_alias(\"external_stickers\")\n    def use_external_stickers(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`external_stickers`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 37\n\n    @flag_value\n    def send_messages_in_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send messages in threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 38\n\n    @flag_value\n    def use_embedded_activities(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use activities (applications\n        with the :attr:`~ApplicationFlags.embedded` flag) in a voice channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return 1 << 39\n\n    @make_permission_alias(\"use_embedded_activities\")\n    def start_embedded_activities(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`use_embedded_activities`.\n\n        .. versionadded:: 2.3\n\n        .. versionchanged:: 2.6\n            Became an alias for :attr:`use_embedded_activities`.\n        \"\"\"\n        return 1 << 39\n\n    @flag_value\n    def moderate_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can perform limited moderation actions,\n        such as timeouts or editing members' flags.\n\n        .. versionadded:: 2.3\n        \"\"\"\n        return 1 << 40\n\n    @flag_value\n    def view_creator_monetization_analytics(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view role subscription insights.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 41\n\n    @flag_value\n    def use_soundboard(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use the soundboard in voice channels.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 42\n\n    @flag_value\n    def create_guild_expressions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create emojis, stickers,\n        and soundboard sounds, as well as edit and delete the ones they created.\n\n        See also :attr:`manage_guild_expressions`.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 43\n\n    @flag_value\n    def create_events(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create guild scheduled events,\n        as well as edit and delete the ones they created.\n\n        See also :attr:`manage_events`.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 44\n\n    @flag_value\n    def use_external_sounds(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use custom soundboard sounds from other guilds.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 45\n\n    @flag_value\n    def send_voice_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send voice messages.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 46\n\n    @flag_value\n    def send_polls(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send polls.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 49\n\n    @flag_value\n    def use_external_apps(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's apps can send public responses.\n\n        If disabled, users can still use their user-installed applications, but the responses\n        will be forced ephemeral (i.e. only visible to them).\n        Only applies to user-installed apps that are not also installed to the guild.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 50\n\n    @flag_value\n    def pin_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can pin and unpin messages.\n\n        .. versionadded:: 2.11\n        \"\"\"\n        return 1 << 51\n\n    @flag_value\n    def bypass_slowmode(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can bypass slowmode restrictions.\n\n        Bots are unaffected by slowmode regardless of this permission.\n\n        .. versionadded:: 2.12\n        \"\"\"\n        return 1 << 52", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 35157}, "tests/ui/test_action_row.py::125": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow"], "enclosing_function": "test_remove_item", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/test_colour.py::23": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Colour"], "enclosing_function": "test_compare", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_permissions.py::227": {"resolved_imports": ["disnake/permissions.py"], "used_names": ["PermissionOverwrite"], "enclosing_function": "test_set", "extracted_code": "# Source: disnake/permissions.py\nclass PermissionOverwrite:\n    r\"\"\"A type that is used to represent a channel specific permission.\n\n    Unlike a regular :class:`Permissions`\\, the default value of a\n    permission is equivalent to :data:`None` and not ``False``. Setting\n    a value to ``False`` is **explicitly** denying that permission,\n    while setting a value to ``True`` is **explicitly** allowing\n    that permission.\n\n    The values supported by this are the same as :class:`Permissions`\n    with the added possibility of it being set to :data:`None`.\n\n    .. collapse:: operations\n\n        .. describe:: x == y\n\n            Checks if two overwrites are equal.\n        .. describe:: x != y\n\n            Checks if two overwrites are not equal.\n        .. describe:: iter(x)\n\n           Returns an iterator of ``(perm, value)`` pairs. This allows it\n           to be, for example, constructed as a dict or a list of pairs.\n           Note that aliases are not shown.\n\n    Parameters\n    ----------\n    **kwargs\n        Set the value of permissions by their name.\n    \"\"\"\n\n    __slots__ = (\"_values\",)\n\n    # n. b. this typechecking block must be first and separate from the secondary one, due to codemodding\n    if TYPE_CHECKING:\n        add_reactions: bool | None\n        administrator: bool | None\n        attach_files: bool | None\n        ban_members: bool | None\n        bypass_slowmode: bool | None\n        change_nickname: bool | None\n        connect: bool | None\n        create_events: bool | None\n        create_forum_threads: bool | None\n        create_guild_expressions: bool | None\n        create_instant_invite: bool | None\n        create_private_threads: bool | None\n        create_public_threads: bool | None\n        deafen_members: bool | None\n        embed_links: bool | None\n        external_emojis: bool | None\n        external_stickers: bool | None\n        kick_members: bool | None\n        manage_channels: bool | None\n        manage_emojis: bool | None\n        manage_emojis_and_stickers: bool | None\n        manage_events: bool | None\n        manage_guild: bool | None\n        manage_guild_expressions: bool | None\n        manage_messages: bool | None\n        manage_nicknames: bool | None\n        manage_permissions: bool | None\n        manage_roles: bool | None\n        manage_threads: bool | None\n        manage_webhooks: bool | None\n        mention_everyone: bool | None\n        moderate_members: bool | None\n        move_members: bool | None\n        mute_members: bool | None\n        pin_messages: bool | None\n        priority_speaker: bool | None\n        read_message_history: bool | None\n        read_messages: bool | None\n        request_to_speak: bool | None\n        send_messages: bool | None\n        send_messages_in_threads: bool | None\n        send_polls: bool | None\n        send_tts_messages: bool | None\n        send_voice_messages: bool | None\n        speak: bool | None\n        start_embedded_activities: bool | None\n        stream: bool | None\n        use_application_commands: bool | None\n        use_embedded_activities: bool | None\n        use_external_apps: bool | None\n        use_external_emojis: bool | None\n        use_external_sounds: bool | None\n        use_external_stickers: bool | None\n        use_slash_commands: bool | None\n        use_soundboard: bool | None\n        use_voice_activation: bool | None\n        view_audit_log: bool | None\n        view_channel: bool | None\n        view_creator_monetization_analytics: bool | None\n        view_guild_insights: bool | None\n\n    if TYPE_CHECKING:\n        VALID_NAMES: ClassVar[set[str]]\n        PURE_FLAGS: ClassVar[set[str]]\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        *,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def __init__(self, **kwargs: bool | None) -> None:\n        self._values: dict[str, bool | None] = {}\n\n        for key, value in kwargs.items():\n            if key not in self.VALID_NAMES:\n                msg = f\"{key!r} is not a valid permission name.\"\n                raise ValueError(msg)\n\n            setattr(self, key, value)\n\n    def __eq__(self, other: object) -> bool:\n        return isinstance(other, PermissionOverwrite) and self._values == other._values\n\n    def _set(self, key: str, value: bool | None) -> None:\n        if value not in (True, None, False):\n            msg = f\"Expected bool or NoneType, received {value.__class__.__name__}\"\n            raise TypeError(msg)\n\n        if value is None:\n            self._values.pop(key, None)\n        else:\n            self._values[key] = value\n\n    def pair(self) -> tuple[Permissions, Permissions]:\n        r\"\"\":class:`tuple`\\[:class:`Permissions`, :class:`Permissions`]: Returns the (allow, deny) pair from this overwrite.\"\"\"\n        allow = Permissions.none()\n        deny = Permissions.none()\n\n        for key, value in self._values.items():\n            if value is True:\n                setattr(allow, key, True)\n            elif value is False:\n                setattr(deny, key, True)\n\n        return allow, deny\n\n    @classmethod\n    def from_pair(cls, allow: Permissions, deny: Permissions) -> Self:\n        \"\"\"Creates an overwrite from an allow/deny pair of :class:`Permissions`.\"\"\"\n        ret = cls()\n        for key, value in allow:\n            if value is True:\n                setattr(ret, key, True)\n\n        for key, value in deny:\n            if value is True:\n                setattr(ret, key, False)\n\n        return ret\n\n    def is_empty(self) -> bool:\n        \"\"\"Checks if the permission overwrite is currently empty.\n\n        An empty permission overwrite is one that has no overwrites set\n        to ``True`` or ``False``.\n\n        Returns\n        -------\n        :class:`bool`\n            Indicates if the overwrite is empty.\n        \"\"\"\n        return len(self._values) == 0\n\n    @overload\n    @_generated\n    def update(\n        self,\n        *,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def update(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def update(self, **kwargs: bool | None) -> None:\n        \"\"\"Bulk updates this permission overwrite object.\n\n        Allows you to set multiple attributes by using keyword\n        arguments. The names must be equivalent to the properties\n        listed. Extraneous key/value pairs will be silently ignored.\n\n        Parameters\n        ----------\n        **kwargs\n            A list of key/value pairs to bulk update with.\n        \"\"\"\n        for key, value in kwargs.items():\n            if key not in self.VALID_NAMES:\n                continue\n\n            setattr(self, key, value)\n\n    def __iter__(self) -> Iterator[tuple[str, bool | None]]:\n        for key in self.PURE_FLAGS:\n            yield key, self._values.get(key)", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 12272}, "tests/test_flags.py::149": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": [], "enclosing_function": "test_flag_value_xor", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_utils.py::448": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["asyncio", "helpers", "pytest", "timedelta", "utils"], "enclosing_function": "test_sleep_until", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ui/test_decorators.py::65": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/button.py"], "used_names": ["Any", "assert_type", "pytest", "ui"], "enclosing_function": "test_cls", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 8, "n_files_resolved": 3, "n_chars_extracted": 1281}, "tests/test_events.py::62": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Any", "Event", "disnake", "pytest"], "enclosing_function": "test_addremove_listener", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/test_utils.py::265": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Callable", "utils"], "enclosing_function": "test_maybe_cast", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_slash_core.py::48": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_parents", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_embeds.py::196": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_attr_proxy", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ext/commands/test_params.py::113": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Any", "commands", "pytest"], "enclosing_function": "test_ellipsis", "extracted_code": "", "n_imports_parsed": 7, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/interactions/test_base.py::170": {"resolved_imports": ["disnake/__init__.py", "disnake/state.py"], "used_names": ["disnake"], "enclosing_function": "test_init_member", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 8, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/test_abc.py::66": {"resolved_imports": ["disnake/__init__.py", "disnake/abc.py"], "used_names": ["GuildChannel", "disnake", "mock"], "enclosing_function": "test_all", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\n\n\n# Source: disnake/abc.py\nclass GuildChannel(ABC):\n    \"\"\"An ABC that details the common operations on a Discord guild channel.\n\n    The following classes implement this ABC:\n\n    - :class:`.TextChannel`\n    - :class:`.VoiceChannel`\n    - :class:`.CategoryChannel`\n    - :class:`.StageChannel`\n    - :class:`.ForumChannel`\n    - :class:`.MediaChannel`\n\n    This ABC must also implement :class:`.abc.Snowflake`.\n\n    Attributes\n    ----------\n    name: :class:`str`\n        The channel name.\n    guild: :class:`.Guild`\n        The guild the channel belongs to.\n    position: :class:`int`\n        The position in the channel list. This is a number that starts at 0.\n        e.g. the top channel is position 0.\n    \"\"\"\n\n    __slots__ = ()\n\n    id: int\n    name: str\n    guild: Guild\n    type: ChannelType\n    position: int\n    category_id: int | None\n    _flags: int\n    _state: ConnectionState\n    _overwrites: list[_Overwrites]\n\n    if TYPE_CHECKING:\n\n        def __init__(\n            self, *, state: ConnectionState, guild: Guild, data: Mapping[str, Any]\n        ) -> None: ...\n\n    def __str__(self) -> str:\n        return self.name\n\n    @property\n    def _sorting_bucket(self) -> int:\n        raise NotImplementedError\n\n    def _update(self, guild: Guild, data: dict[str, Any]) -> None:\n        raise NotImplementedError\n\n    async def _move(\n        self,\n        position: int,\n        parent_id: int | None = None,\n        lock_permissions: bool = False,\n        *,\n        reason: str | None,\n    ) -> None:\n        if position < 0:\n            msg = \"Channel position cannot be less than 0.\"\n            raise ValueError(msg)\n\n        http = self._state.http\n        bucket = self._sorting_bucket\n        channels = [c for c in self.guild.channels if c._sorting_bucket == bucket]\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        channels.sort(key=lambda c: c.position)\n\n        try:\n            # remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # not there somehow lol\n            return\n        else:\n            index = next(\n                (i for i, c in enumerate(channels) if c.position >= position), len(channels)\n            )\n            # add ourselves at our designated position\n            channels.insert(index, self)\n\n        payload: list[ChannelPositionUpdatePayload] = []\n        for index, c in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": c.id, \"position\": index}\n            if parent_id is not MISSING and c.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def _edit(\n        self,\n        *,\n        name: str = MISSING,\n        topic: str | None = MISSING,\n        position: int = MISSING,\n        nsfw: bool = MISSING,\n        sync_permissions: bool = MISSING,\n        category: Snowflake | None = MISSING,\n        slowmode_delay: int | None = MISSING,\n        default_thread_slowmode_delay: int | None = MISSING,\n        default_auto_archive_duration: AnyThreadArchiveDuration | None = MISSING,\n        type: ChannelType = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        bitrate: int = MISSING,\n        user_limit: int = MISSING,\n        rtc_region: str | VoiceRegion | None = MISSING,\n        video_quality_mode: VideoQualityMode = MISSING,\n        flags: ChannelFlags = MISSING,\n        available_tags: Sequence[ForumTag] = MISSING,\n        default_reaction: str | Emoji | PartialEmoji | None = MISSING,\n        default_sort_order: ThreadSortOrder | None = MISSING,\n        default_layout: ThreadLayout = MISSING,\n        reason: str | None = None,\n    ) -> ChannelPayload | None:\n        parent_id: int | None\n        if category is not MISSING:\n            # if category is given, it's either `None` (no parent) or a category channel\n            parent_id = category.id if category else None\n        else:\n            # if it's not given, don't change the category\n            parent_id = MISSING\n\n        rtc_region_payload: str | None\n        if rtc_region is not MISSING:\n            rtc_region_payload = str(rtc_region) if rtc_region is not None else None\n        else:\n            rtc_region_payload = MISSING\n\n        video_quality_mode_payload: int | None\n        if video_quality_mode is not MISSING:\n            video_quality_mode_payload = int(video_quality_mode)\n        else:\n            video_quality_mode_payload = MISSING\n\n        default_auto_archive_duration_payload: int | None\n        if default_auto_archive_duration is not MISSING:\n            default_auto_archive_duration_payload = (\n                int(default_auto_archive_duration)\n                if default_auto_archive_duration is not None\n                else default_auto_archive_duration\n            )\n        else:\n            default_auto_archive_duration_payload = MISSING\n\n        lock_permissions: bool = bool(sync_permissions)\n\n        overwrites_payload: list[PermissionOverwritePayload] = MISSING\n\n        if position is not MISSING:\n            await self._move(\n                position, parent_id=parent_id, lock_permissions=lock_permissions, reason=reason\n            )\n            parent_id = MISSING  # no need to change it again in the edit request below\n        elif lock_permissions:\n            if parent_id is not MISSING:\n                p_id = parent_id\n            else:\n                p_id = self.category_id\n\n            if p_id is not None and (parent := self.guild.get_channel(p_id)):\n                overwrites_payload = [c._asdict() for c in parent._overwrites]\n\n        if overwrites not in (MISSING, None):\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": _Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER,\n                }\n                overwrites_payload.append(payload)\n\n        type_payload: int\n        if type is not MISSING:\n            if not isinstance(type, ChannelType):\n                msg = \"type field must be of type ChannelType\"\n                raise TypeError(msg)\n            type_payload = type.value\n        else:\n            type_payload = MISSING\n\n        flags_payload: int\n        if flags is not MISSING:\n            if not isinstance(flags, ChannelFlags):\n                msg = \"flags field must be of type ChannelFlags\"\n                raise TypeError(msg)\n            flags_payload = flags.value\n        else:\n            flags_payload = MISSING\n\n        available_tags_payload: list[PartialForumTagPayload] = MISSING\n        if available_tags is not MISSING:\n            available_tags_payload = [tag.to_dict() for tag in available_tags]\n\n        default_reaction_emoji_payload: DefaultReactionPayload | None = MISSING\n        if default_reaction is not MISSING:\n            if default_reaction is not None:\n                emoji_name, emoji_id = PartialEmoji._emoji_to_name_id(default_reaction)\n                default_reaction_emoji_payload = {\n                    \"emoji_name\": emoji_name,\n                    \"emoji_id\": emoji_id,\n                }\n            else:\n                default_reaction_emoji_payload = None\n\n        default_sort_order_payload: int | None = MISSING\n        if default_sort_order is not MISSING:\n            default_sort_order_payload = (\n                try_enum_to_int(default_sort_order) if default_sort_order is not None else None\n            )\n\n        default_layout_payload: int = MISSING\n        if default_layout is not MISSING:\n            default_layout_payload = try_enum_to_int(default_layout)\n\n        options: dict[str, Any] = {\n            \"name\": name,\n            \"parent_id\": parent_id,\n            \"topic\": topic,\n            \"bitrate\": bitrate,\n            \"nsfw\": nsfw,\n            \"user_limit\": user_limit,\n            # note: not passing `position` as it already got updated before, if passed\n            \"permission_overwrites\": overwrites_payload,\n            \"rate_limit_per_user\": slowmode_delay,\n            \"default_thread_rate_limit_per_user\": default_thread_slowmode_delay,\n            \"type\": type_payload,\n            \"rtc_region\": rtc_region_payload,\n            \"video_quality_mode\": video_quality_mode_payload,\n            \"default_auto_archive_duration\": default_auto_archive_duration_payload,\n            \"flags\": flags_payload,\n            \"available_tags\": available_tags_payload,\n            \"default_reaction_emoji\": default_reaction_emoji_payload,\n            \"default_sort_order\": default_sort_order_payload,\n            \"default_forum_layout\": default_layout_payload,\n        }\n        options = {k: v for k, v in options.items() if v is not MISSING}\n\n        if options:\n            return await self._state.http.edit_channel(self.id, reason=reason, **options)\n        return None\n\n    def _fill_overwrites(self, data: GuildChannelPayload) -> None:\n        self._overwrites = []\n        everyone_index = 0\n        everyone_id = self.guild.id\n\n        for index, overridden in enumerate(data.get(\"permission_overwrites\", [])):\n            overwrite = _Overwrites(overridden)\n            self._overwrites.append(overwrite)\n\n            if overwrite.type == _Overwrites.MEMBER:\n                continue\n\n            if overwrite.id == everyone_id:\n                # the @everyone role is not guaranteed to be the first one\n                # in the list of permission overwrites, however the permission\n                # resolution code kind of requires that it is the first one in\n                # the list since it is special. So we need the index so we can\n                # swap it to be the first one.\n                everyone_index = index\n\n        # do the swap\n        tmp = self._overwrites\n        if tmp:\n            tmp[everyone_index], tmp[0] = tmp[0], tmp[everyone_index]\n\n    @property\n    def changed_roles(self) -> list[Role]:\n        r\"\"\":class:`list`\\[:class:`.Role`]: Returns a list of roles that have been overridden from\n        their default values in the :attr:`.Guild.roles` attribute.\n        \"\"\"\n        ret: list[Role] = []\n        g = self.guild\n        for overwrite in filter(lambda o: o.is_role(), self._overwrites):\n            role = g.get_role(overwrite.id)\n            if role is None:\n                continue\n\n            role = copy.copy(role)\n            role.permissions.handle_overwrite(overwrite.allow, overwrite.deny)\n            ret.append(role)\n        return ret\n\n    @property\n    def mention(self) -> str:\n        \"\"\":class:`str`: The string that allows you to mention the channel.\"\"\"\n        return f\"<#{self.id}>\"\n\n    @property\n    def created_at(self) -> datetime:\n        \"\"\":class:`datetime.datetime`: Returns the channel's creation time in UTC.\"\"\"\n        return utils.snowflake_time(self.id)\n\n    def overwrites_for(self, obj: Role | User) -> PermissionOverwrite:\n        \"\"\"Returns the channel-specific overwrites for a member or a role.\n\n        Parameters\n        ----------\n        obj: :class:`.Role` | :class:`.abc.User`\n            The role or user denoting\n            whose overwrite to get.\n\n        Returns\n        -------\n        :class:`~disnake.PermissionOverwrite`\n            The permission overwrites for this object.\n        \"\"\"\n        predicate: Callable[[_Overwrites], bool]\n        if isinstance(obj, User):\n            predicate = lambda p: p.is_member()\n        elif isinstance(obj, Role):\n            predicate = lambda p: p.is_role()\n        else:\n            predicate = lambda p: True\n\n        for overwrite in filter(predicate, self._overwrites):\n            if overwrite.id == obj.id:\n                allow = Permissions(overwrite.allow)\n                deny = Permissions(overwrite.deny)\n                return PermissionOverwrite.from_pair(allow, deny)\n\n        return PermissionOverwrite()\n\n    @property\n    def overwrites(self) -> dict[Role | Member, PermissionOverwrite]:\n        r\"\"\"Returns all of the channel's overwrites.\n\n        This is returned as a dictionary where the key contains the target which\n        can be either a :class:`~disnake.Role` or a :class:`~disnake.Member` and the value is the\n        overwrite as a :class:`~disnake.PermissionOverwrite`.\n\n        Returns\n        -------\n        :class:`dict`\\[:class:`~disnake.Role` | :class:`~disnake.Member`, :class:`~disnake.PermissionOverwrite`]\n            The channel's permission overwrites.\n        \"\"\"\n        ret = {}\n        for ow in self._overwrites:\n            allow = Permissions(ow.allow)\n            deny = Permissions(ow.deny)\n            overwrite = PermissionOverwrite.from_pair(allow, deny)\n            target = None\n\n            if ow.is_role():\n                target = self.guild.get_role(ow.id)\n            elif ow.is_member():\n                target = self.guild.get_member(ow.id)\n\n            # TODO: There is potential data loss here in the non-chunked\n            # case, i.e. target is None because get_member returned nothing.\n            # This can be fixed with a slight breaking change to the return type,\n            # i.e. adding disnake.Object to the list of it\n            # However, for now this is an acceptable compromise.\n            if target is not None:\n                ret[target] = overwrite\n        return ret\n\n    @property\n    def category(self) -> CategoryChannel | None:\n        \"\"\":class:`~disnake.CategoryChannel` | :data:`None`: The category this channel belongs to.\n\n        If there is no category then this is :data:`None`.\n        \"\"\"\n        if isinstance(self.guild, Object):\n            return None\n        return self.guild.get_channel(self.category_id)  # pyright: ignore[reportArgumentType, reportReturnType]\n\n    @property\n    def permissions_synced(self) -> bool:\n        \"\"\":class:`bool`: Whether or not the permissions for this channel are synced with the\n        category it belongs to.\n\n        If there is no category then this is ``False``.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self.category_id is None or isinstance(self.guild, Object):\n            return False\n\n        category = self.guild.get_channel(self.category_id)\n        return bool(category and category.overwrites == self.overwrites)\n\n    @property\n    def flags(self) -> ChannelFlags:\n        \"\"\":class:`.ChannelFlags`: The channel flags for this channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return ChannelFlags._from_value(self._flags)\n\n    @property\n    def jump_url(self) -> str:\n        \"\"\"A URL that can be used to jump to this channel.\n\n        .. versionadded:: 2.4\n\n        .. note::\n\n            This exists for all guild channels but may not be usable by the client for all guild channel types.\n        \"\"\"\n        return f\"https://discord.com/channels/{self.guild.id}/{self.id}\"\n\n    def _apply_implict_permissions(self, base: Permissions) -> None:\n        # if you can't send a message in a channel then you can't have certain\n        # permissions as well\n        if not base.send_messages:\n            base.send_tts_messages = False\n            base.send_voice_messages = False\n            base.send_polls = False\n            base.mention_everyone = False\n            base.embed_links = False\n            base.attach_files = False\n\n        # if you can't view a channel then you have no permissions there\n        if not base.view_channel:\n            denied = Permissions.all_channel()\n            base.value &= ~denied.value\n\n    def permissions_for(\n        self,\n        obj: Member | Role,\n        /,\n        *,\n        ignore_timeout: bool = MISSING,\n    ) -> Permissions:\n        \"\"\"Handles permission resolution for the :class:`~disnake.Member`\n        or :class:`~disnake.Role`.\n\n        This function takes into consideration the following cases:\n\n        - Guild owner\n        - Guild roles\n        - Channel overrides\n        - Member overrides\n        - Timeouts\n\n        If a :class:`~disnake.Role` is passed, then it checks the permissions\n        someone with that role would have, which is essentially:\n\n        - The default role permissions\n        - The permissions of the role used as a parameter\n        - The default role permission overwrites\n        - The permission overwrites of the role used as a parameter\n\n        .. note::\n            If the channel originated from an :class:`.Interaction` and\n            the :attr:`.guild` attribute is unavailable, such as with\n            user-installed applications in guilds, this method will not work\n            due to an API limitation.\n            Consider using :attr:`.Interaction.permissions` or :attr:`~.Interaction.app_permissions` instead.\n\n        .. versionchanged:: 2.0\n            The object passed in can now be a role object.\n\n        Parameters\n        ----------\n        obj: :class:`~disnake.Member` | :class:`~disnake.Role`\n            The object to resolve permissions for. This could be either\n            a member or a role. If it's a role then member overwrites\n            are not computed.\n        ignore_timeout: :class:`bool`\n            Whether or not to ignore the user's timeout.\n            Defaults to ``False``.\n\n            .. versionadded:: 2.4\n\n            .. note::\n\n                This only applies to :class:`~disnake.Member` objects.\n\n            .. versionchanged:: 2.6\n\n                The default was changed to ``False``.\n\n        Raises\n        ------\n        TypeError\n            ``ignore_timeout`` is only supported for :class:`~disnake.Member` objects.\n\n        Returns\n        -------\n        :class:`~disnake.Permissions`\n            The resolved permissions for the member or role.\n        \"\"\"\n        # The current cases can be explained as:\n        # Guild owner get all permissions -- no questions asked. Otherwise...\n        # The @everyone role gets the first application.\n        # After that, the applied roles that the user has in the channel\n        # (or otherwise) are then OR'd together.\n        # After the role permissions are resolved, the member permissions\n        # have to take into effect.\n        # After all that is done.. you have to do the following:\n\n        # The operation first takes into consideration the denied\n        # and then the allowed.\n\n        # Timeouted users have only view_channel and read_message_history\n        # if they already have them.\n        if ignore_timeout is not MISSING and isinstance(obj, Role):\n            msg = \"ignore_timeout is only supported for disnake.Member objects\"\n            raise TypeError(msg)\n\n        if ignore_timeout is MISSING:\n            ignore_timeout = False\n\n        if self.guild.owner_id == obj.id:\n            return Permissions.all()\n\n        default = self.guild.default_role\n        base = Permissions(default.permissions.value)\n\n        # Handle the role case first\n        if isinstance(obj, Role):\n            base.value |= obj._permissions\n\n            if base.administrator:\n                return Permissions.all()\n\n            # Apply @everyone allow/deny first since it's special\n            try:\n                maybe_everyone = self._overwrites[0]\n                if maybe_everyone.id == self.guild.id:\n                    base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n            except IndexError:\n                pass\n\n            if obj.is_default():\n                return base\n\n            overwrite = utils.get(self._overwrites, type=_Overwrites.ROLE, id=obj.id)\n            if overwrite is not None:\n                base.handle_overwrite(overwrite.allow, overwrite.deny)\n\n            return base\n\n        roles = obj._roles\n        get_role = self.guild.get_role\n\n        # Apply guild roles that the member has.\n        for role_id in roles:\n            role = get_role(role_id)\n            if role is not None:\n                base.value |= role._permissions\n\n        # Guild-wide Administrator -> True for everything\n        # Bypass all channel-specific overrides\n        if base.administrator:\n            return Permissions.all()\n\n        # Apply @everyone allow/deny first since it's special\n        try:\n            maybe_everyone = self._overwrites[0]\n            if maybe_everyone.id == self.guild.id:\n                base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n                remaining_overwrites = self._overwrites[1:]\n            else:\n                remaining_overwrites = self._overwrites\n        except IndexError:\n            remaining_overwrites = self._overwrites\n\n        denies = 0\n        allows = 0\n\n        # Apply channel specific role permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_role() and roles.has(overwrite.id):\n                denies |= overwrite.deny\n                allows |= overwrite.allow\n\n        base.handle_overwrite(allow=allows, deny=denies)\n\n        # Apply member specific permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_member() and overwrite.id == obj.id:\n                base.handle_overwrite(allow=overwrite.allow, deny=overwrite.deny)\n                break\n\n        # if you have a timeout then you can't have any permissions\n        # except read messages and read message history\n        if not ignore_timeout and obj.current_timeout:\n            allowed = Permissions(view_channel=True, read_message_history=True)\n            base.value &= allowed.value\n\n        return base\n\n    async def delete(self, *, reason: str | None = None) -> None:\n        \"\"\"|coro|\n\n        Deletes the channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to do this.\n\n        Parameters\n        ----------\n        reason: :class:`str` | :data:`None`\n            The reason for deleting this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to delete the channel.\n        NotFound\n            The channel was not found or was already deleted.\n        HTTPException\n            Deleting the channel failed.\n        \"\"\"\n        await self._state.http.delete_channel(self.id, reason=reason)\n\n    @overload\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        overwrite: PermissionOverwrite | None = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_overload_with_permissions\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        reason: str | None = ...,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    async def set_permissions(\n        self,\n        target,\n        *,\n        overwrite: PermissionOverwrite | None = MISSING,\n        reason: str | None = None,\n        **permissions,\n    ) -> None:\n        \"\"\"|coro|\n\n        Sets the channel specific permission overwrites for a target in the\n        channel.\n\n        The ``target`` parameter should either be a :class:`.Member` or a\n        :class:`.Role` that belongs to guild.\n\n        The ``overwrite`` parameter, if given, must either be :data:`None` or\n        :class:`.PermissionOverwrite`. For convenience, you can pass in\n        keyword arguments denoting :class:`.Permissions` attributes. If this is\n        done, then you cannot mix the keyword arguments with the ``overwrite``\n        parameter.\n\n        If the ``overwrite`` parameter is :data:`None`, then the permission\n        overwrites are deleted.\n\n        You must have :attr:`.Permissions.manage_roles` permission to do this.\n\n        .. note::\n\n            This method *replaces* the old overwrites with the ones given.\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` instead of ``InvalidArgument``.\n\n        Examples\n        --------\n        Setting allow and deny: ::\n\n            await message.channel.set_permissions(message.author, view_channel=True,\n                                                                  send_messages=False)\n\n        Deleting overwrites ::\n\n            await channel.set_permissions(member, overwrite=None)\n\n        Using :class:`.PermissionOverwrite` ::\n\n            overwrite = disnake.PermissionOverwrite()\n            overwrite.send_messages = False\n            overwrite.view_channel = True\n            await channel.set_permissions(member, overwrite=overwrite)\n\n        Parameters\n        ----------\n        target: :class:`.Member` | :class:`.Role`\n            The member or role to overwrite permissions for.\n        overwrite: :class:`.PermissionOverwrite` | :data:`None`\n            The permissions to allow and deny to the target, or :data:`None` to\n            delete the overwrite.\n        **permissions\n            A keyword argument list of permissions to set for ease of use.\n            Cannot be mixed with ``overwrite``.\n        reason: :class:`str` | :data:`None`\n            The reason for doing this action. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to edit channel specific permissions.\n        HTTPException\n            Editing channel specific permissions failed.\n        NotFound\n            The role or member being edited is not part of the guild.\n        TypeError\n            ``overwrite`` is invalid,\n            the target type was not :class:`.Role` or :class:`.Member`,\n            both keyword arguments and ``overwrite`` were provided,\n            or invalid permissions were provided as keyword arguments.\n        \"\"\"\n        http = self._state.http\n\n        if isinstance(target, User):\n            perm_type = _Overwrites.MEMBER\n        elif isinstance(target, Role):\n            perm_type = _Overwrites.ROLE\n        else:\n            msg = \"target parameter must be either Member or Role\"\n            raise TypeError(msg)\n\n        if overwrite is MISSING:\n            if len(permissions) == 0:\n                msg = \"No overwrite provided.\"\n                raise TypeError(msg)\n            try:\n                overwrite = PermissionOverwrite(**permissions)\n            except (ValueError, TypeError) as e:\n                msg = \"Invalid permissions given to keyword arguments.\"\n                raise TypeError(msg) from e\n        else:\n            if len(permissions) > 0:\n                msg = \"Cannot mix overwrite and keyword arguments.\"\n                raise TypeError(msg)\n\n        # TODO: wait for event\n\n        if overwrite is None:\n            await http.delete_channel_permissions(self.id, target.id, reason=reason)\n        elif isinstance(overwrite, PermissionOverwrite):\n            (allow, deny) = overwrite.pair()\n            await http.edit_channel_permissions(\n                self.id, target.id, allow.value, deny.value, perm_type, reason=reason\n            )\n        else:\n            msg = \"Invalid overwrite type provided.\"\n            raise TypeError(msg)\n\n    async def _clone_impl(\n        self,\n        base_attrs: dict[str, Any],\n        *,\n        name: str | None = None,\n        category: Snowflake | None = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        reason: str | None = None,\n    ) -> Self:\n        # if the overwrites are MISSING, defaults to the\n        # original permissions of the channel\n        overwrites_payload: list[PermissionOverwritePayload]\n        if overwrites is not MISSING:\n            if not isinstance(overwrites, dict):\n                msg = \"overwrites parameter expects a dict.\"\n                raise TypeError(msg)\n\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": (_Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER),\n                }\n                overwrites_payload.append(payload)\n        else:\n            overwrites_payload = [x._asdict() for x in self._overwrites]\n        base_attrs[\"permission_overwrites\"] = overwrites_payload\n        if category is not MISSING:\n            base_attrs[\"parent_id\"] = category.id if category else None\n        else:\n            # if no category was given don't change the category\n            base_attrs[\"parent_id\"] = self.category_id\n        base_attrs[\"name\"] = name or self.name\n        channel_type = base_attrs.get(\"type\") or self.type.value\n        guild_id = self.guild.id\n        cls = self.__class__\n        data = await self._state.http.create_channel(\n            guild_id, channel_type, reason=reason, **base_attrs\n        )\n        obj = cls(state=self._state, guild=self.guild, data=data)\n\n        # temporarily add it to the cache\n        self.guild._channels[obj.id] = obj  # pyright: ignore[reportArgumentType]\n        return obj\n\n    async def clone(self, *, name: str | None = None, reason: str | None = None) -> Self:\n        \"\"\"|coro|\n\n        Clones this channel. This creates a channel with the same properties\n        as this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. versionadded:: 1.1\n\n        Parameters\n        ----------\n        name: :class:`str` | :data:`None`\n            The name of the new channel. If not provided, defaults to this channel name.\n        reason: :class:`str` | :data:`None`\n            The reason for cloning this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have the proper permissions to create this channel.\n        HTTPException\n            Creating the channel failed.\n\n        Returns\n        -------\n        :class:`.abc.GuildChannel`\n            The channel that was created.\n        \"\"\"\n        raise NotImplementedError\n\n    @overload\n    async def move(\n        self,\n        *,\n        beginning: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        end: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        before: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        after: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    async def move(self, **kwargs: Any) -> None:\n        \"\"\"|coro|\n\n        A rich interface to help move a channel relative to other channels.\n\n        If exact position movement is required, ``edit`` should be used instead.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. note::\n\n            Voice channels will always be sorted below text channels.\n            This is a Discord limitation.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` or :exc:`ValueError` instead of ``InvalidArgument``.\n\n        Parameters\n        ----------\n        beginning: :class:`bool`\n            Whether to move the channel to the beginning of the\n            channel list (or category if given).\n            This is mutually exclusive with ``end``, ``before``, and ``after``.\n        end: :class:`bool`\n            Whether to move the channel to the end of the\n            channel list (or category if given).\n            This is mutually exclusive with ``beginning``, ``before``, and ``after``.\n        before: :class:`.abc.Snowflake`\n            The channel that should be before our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``after``.\n        after: :class:`.abc.Snowflake`\n            The channel that should be after our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``before``.\n        offset: :class:`int`\n            The number of channels to offset the move by. For example,\n            an offset of ``2`` with ``beginning=True`` would move\n            it 2 after the beginning. A positive number moves it below\n            while a negative number moves it above. Note that this\n            number is relative and computed after the ``beginning``,\n            ``end``, ``before``, and ``after`` parameters.\n        category: :class:`.abc.Snowflake` | :data:`None`\n            The category to move this channel under.\n            If :data:`None` is given then it moves it out of the category.\n            This parameter is ignored if moving a category channel.\n        sync_permissions: :class:`bool`\n            Whether to sync the permissions with the category (if given).\n        reason: :class:`str` | :data:`None`\n            The reason for moving this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to move the channel.\n        HTTPException\n            Moving the channel failed.\n        TypeError\n            A bad mix of arguments were passed.\n        ValueError\n            An invalid position was given.\n        \"\"\"\n        if not kwargs:\n            return\n\n        beginning, end = kwargs.get(\"beginning\"), kwargs.get(\"end\")\n        before, after = kwargs.get(\"before\"), kwargs.get(\"after\")\n        offset = kwargs.get(\"offset\", 0)\n        if sum(bool(a) for a in (beginning, end, before, after)) > 1:\n            msg = \"Only one of [before, after, end, beginning] can be used.\"\n            raise TypeError(msg)\n\n        bucket = self._sorting_bucket\n        parent_id = kwargs.get(\"category\", MISSING)\n        if parent_id not in (MISSING, None):\n            parent_id = parent_id.id\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == parent_id\n            ]\n        else:\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == self.category_id\n            ]\n\n        channels.sort(key=lambda c: (c.position, c.id))\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        try:\n            # Try to remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # If we're not there then it's probably due to not being in the category\n            pass\n\n        index = None\n        if beginning:\n            index = 0\n        elif end:\n            index = len(channels)\n        elif before:\n            index = next((i for i, c in enumerate(channels) if c.id == before.id), None)\n        elif after:\n            index = next((i + 1 for i, c in enumerate(channels) if c.id == after.id), None)\n\n        if index is None:\n            msg = \"Could not resolve appropriate move position\"\n            raise ValueError(msg)\n\n        channels.insert(max((index + offset), 0), self)\n        payload: list[ChannelPositionUpdatePayload] = []\n        lock_permissions = kwargs.get(\"sync_permissions\", False)\n        reason = kwargs.get(\"reason\")\n        for index, channel in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": channel.id, \"position\": index}\n            if parent_id is not MISSING and channel.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await self._state.http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def create_invite(\n        self,\n        *,\n        reason: str | None = None,\n        max_age: int = 0,\n        max_uses: int = 0,\n        temporary: bool = False,\n        unique: bool = True,\n        target_type: InviteTarget | None = None,\n        target_user: User | None = None,\n        target_application: Snowflake | PartyType | None = None,\n        guild_scheduled_event: GuildScheduledEvent | None = None,\n    ) -> Invite:\n        \"\"\"|coro|\n\n        Creates an instant invite from a text or voice channel.\n\n        You must have :attr:`.Permissions.create_instant_invite` permission to\n        do this.\n\n        Parameters\n        ----------\n        max_age: :class:`int`\n            How long the invite should last in seconds. If set to ``0``, then the invite\n            doesn't expire. Defaults to ``0``.\n        max_uses: :class:`int`\n            How many uses the invite could be used for. If it's 0 then there\n            are unlimited uses. Defaults to ``0``.\n        temporary: :class:`bool`\n            Whether the invite grants temporary membership\n            (i.e. they get kicked after they disconnect). Defaults to ``False``.\n        unique: :class:`bool`\n            Whether a unique invite URL should be created. Defaults to ``True``.\n            If this is set to ``False`` then it will return a previously created\n            invite.\n        target_type: :class:`.InviteTarget` | :data:`None`\n            The type of target for the voice channel invite, if any.\n\n            .. versionadded:: 2.0\n\n        target_user: :class:`User` | :data:`None`\n            The user whose stream to display for this invite, required if ``target_type`` is :attr:`.InviteTarget.stream`.\n            The user must be streaming in the channel.\n\n            .. versionadded:: 2.0\n\n        target_application: :class:`.Snowflake` | :data:`None`\n            The ID of the embedded application for the invite, required if ``target_type`` is :attr:`.InviteTarget.embedded_application`.\n\n            .. versionadded:: 2.0\n\n            .. versionchanged:: 2.9\n                ``PartyType`` is deprecated, and :class:`.Snowflake` should be used instead.\n\n        guild_scheduled_event: :class:`.GuildScheduledEvent` | :data:`None`\n            The guild scheduled event to include with the invite.\n\n            .. versionadded:: 2.3\n\n        reason: :class:`str` | :data:`None`\n            The reason for creating this invite. Shows up on the audit log.\n\n        Raises\n        ------\n        HTTPException\n            Invite creation failed.\n        NotFound\n            The channel that was passed is a category or an invalid channel.\n\n        Returns\n        -------\n        :class:`.Invite`\n            The newly created invite.\n        \"\"\"\n        if isinstance(target_application, PartyType):\n            utils.warn_deprecated(\n                \"PartyType is deprecated and will be removed in future version\",\n                stacklevel=2,\n            )\n            target_application = Object(target_application.value)\n        data = await self._state.http.create_invite(\n            self.id,\n            reason=reason,\n            max_age=max_age,\n            max_uses=max_uses,\n            temporary=temporary,\n            unique=unique,\n            target_type=try_enum_to_int(target_type),\n            target_user_id=target_user.id if target_user else None,\n            target_application_id=target_application.id if target_application else None,\n        )\n        invite = Invite.from_incomplete(data=data, state=self._state)\n        invite.guild_scheduled_event = guild_scheduled_event\n        return invite\n\n    async def invites(self) -> list[Invite]:\n        r\"\"\"|coro|\n\n        Returns a list of all active instant invites from this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to use this.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to get the information.\n        HTTPException\n            An error occurred while fetching the information.\n\n        Returns\n        -------\n        :class:`list`\\[:class:`.Invite`]\n            The list of invites that are currently active.\n        \"\"\"\n        state = self._state\n        data = await state.http.invites_from_channel(self.id)\n        guild = self.guild\n        return [Invite(state=state, data=invite, channel=self, guild=guild) for invite in data]", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 44081}, "tests/test_utils.py::103": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["mock", "pytest", "utils", "warnings"], "enclosing_function": "test_deprecated", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_slash_core.py::50": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_parents", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_flags.py::120": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": ["pytest", "re"], "enclosing_function": "test_flag_value_or", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ui/test_decorators.py::45": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/button.py"], "used_names": ["Any", "assert_type", "ui"], "enclosing_function": "test_default", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 8, "n_files_resolved": 3, "n_chars_extracted": 1281}, "tests/test_abc.py::71": {"resolved_imports": ["disnake/__init__.py", "disnake/abc.py"], "used_names": ["GuildChannel", "disnake", "mock"], "enclosing_function": "test_all", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\n\n\n# Source: disnake/abc.py\nclass GuildChannel(ABC):\n    \"\"\"An ABC that details the common operations on a Discord guild channel.\n\n    The following classes implement this ABC:\n\n    - :class:`.TextChannel`\n    - :class:`.VoiceChannel`\n    - :class:`.CategoryChannel`\n    - :class:`.StageChannel`\n    - :class:`.ForumChannel`\n    - :class:`.MediaChannel`\n\n    This ABC must also implement :class:`.abc.Snowflake`.\n\n    Attributes\n    ----------\n    name: :class:`str`\n        The channel name.\n    guild: :class:`.Guild`\n        The guild the channel belongs to.\n    position: :class:`int`\n        The position in the channel list. This is a number that starts at 0.\n        e.g. the top channel is position 0.\n    \"\"\"\n\n    __slots__ = ()\n\n    id: int\n    name: str\n    guild: Guild\n    type: ChannelType\n    position: int\n    category_id: int | None\n    _flags: int\n    _state: ConnectionState\n    _overwrites: list[_Overwrites]\n\n    if TYPE_CHECKING:\n\n        def __init__(\n            self, *, state: ConnectionState, guild: Guild, data: Mapping[str, Any]\n        ) -> None: ...\n\n    def __str__(self) -> str:\n        return self.name\n\n    @property\n    def _sorting_bucket(self) -> int:\n        raise NotImplementedError\n\n    def _update(self, guild: Guild, data: dict[str, Any]) -> None:\n        raise NotImplementedError\n\n    async def _move(\n        self,\n        position: int,\n        parent_id: int | None = None,\n        lock_permissions: bool = False,\n        *,\n        reason: str | None,\n    ) -> None:\n        if position < 0:\n            msg = \"Channel position cannot be less than 0.\"\n            raise ValueError(msg)\n\n        http = self._state.http\n        bucket = self._sorting_bucket\n        channels = [c for c in self.guild.channels if c._sorting_bucket == bucket]\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        channels.sort(key=lambda c: c.position)\n\n        try:\n            # remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # not there somehow lol\n            return\n        else:\n            index = next(\n                (i for i, c in enumerate(channels) if c.position >= position), len(channels)\n            )\n            # add ourselves at our designated position\n            channels.insert(index, self)\n\n        payload: list[ChannelPositionUpdatePayload] = []\n        for index, c in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": c.id, \"position\": index}\n            if parent_id is not MISSING and c.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def _edit(\n        self,\n        *,\n        name: str = MISSING,\n        topic: str | None = MISSING,\n        position: int = MISSING,\n        nsfw: bool = MISSING,\n        sync_permissions: bool = MISSING,\n        category: Snowflake | None = MISSING,\n        slowmode_delay: int | None = MISSING,\n        default_thread_slowmode_delay: int | None = MISSING,\n        default_auto_archive_duration: AnyThreadArchiveDuration | None = MISSING,\n        type: ChannelType = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        bitrate: int = MISSING,\n        user_limit: int = MISSING,\n        rtc_region: str | VoiceRegion | None = MISSING,\n        video_quality_mode: VideoQualityMode = MISSING,\n        flags: ChannelFlags = MISSING,\n        available_tags: Sequence[ForumTag] = MISSING,\n        default_reaction: str | Emoji | PartialEmoji | None = MISSING,\n        default_sort_order: ThreadSortOrder | None = MISSING,\n        default_layout: ThreadLayout = MISSING,\n        reason: str | None = None,\n    ) -> ChannelPayload | None:\n        parent_id: int | None\n        if category is not MISSING:\n            # if category is given, it's either `None` (no parent) or a category channel\n            parent_id = category.id if category else None\n        else:\n            # if it's not given, don't change the category\n            parent_id = MISSING\n\n        rtc_region_payload: str | None\n        if rtc_region is not MISSING:\n            rtc_region_payload = str(rtc_region) if rtc_region is not None else None\n        else:\n            rtc_region_payload = MISSING\n\n        video_quality_mode_payload: int | None\n        if video_quality_mode is not MISSING:\n            video_quality_mode_payload = int(video_quality_mode)\n        else:\n            video_quality_mode_payload = MISSING\n\n        default_auto_archive_duration_payload: int | None\n        if default_auto_archive_duration is not MISSING:\n            default_auto_archive_duration_payload = (\n                int(default_auto_archive_duration)\n                if default_auto_archive_duration is not None\n                else default_auto_archive_duration\n            )\n        else:\n            default_auto_archive_duration_payload = MISSING\n\n        lock_permissions: bool = bool(sync_permissions)\n\n        overwrites_payload: list[PermissionOverwritePayload] = MISSING\n\n        if position is not MISSING:\n            await self._move(\n                position, parent_id=parent_id, lock_permissions=lock_permissions, reason=reason\n            )\n            parent_id = MISSING  # no need to change it again in the edit request below\n        elif lock_permissions:\n            if parent_id is not MISSING:\n                p_id = parent_id\n            else:\n                p_id = self.category_id\n\n            if p_id is not None and (parent := self.guild.get_channel(p_id)):\n                overwrites_payload = [c._asdict() for c in parent._overwrites]\n\n        if overwrites not in (MISSING, None):\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": _Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER,\n                }\n                overwrites_payload.append(payload)\n\n        type_payload: int\n        if type is not MISSING:\n            if not isinstance(type, ChannelType):\n                msg = \"type field must be of type ChannelType\"\n                raise TypeError(msg)\n            type_payload = type.value\n        else:\n            type_payload = MISSING\n\n        flags_payload: int\n        if flags is not MISSING:\n            if not isinstance(flags, ChannelFlags):\n                msg = \"flags field must be of type ChannelFlags\"\n                raise TypeError(msg)\n            flags_payload = flags.value\n        else:\n            flags_payload = MISSING\n\n        available_tags_payload: list[PartialForumTagPayload] = MISSING\n        if available_tags is not MISSING:\n            available_tags_payload = [tag.to_dict() for tag in available_tags]\n\n        default_reaction_emoji_payload: DefaultReactionPayload | None = MISSING\n        if default_reaction is not MISSING:\n            if default_reaction is not None:\n                emoji_name, emoji_id = PartialEmoji._emoji_to_name_id(default_reaction)\n                default_reaction_emoji_payload = {\n                    \"emoji_name\": emoji_name,\n                    \"emoji_id\": emoji_id,\n                }\n            else:\n                default_reaction_emoji_payload = None\n\n        default_sort_order_payload: int | None = MISSING\n        if default_sort_order is not MISSING:\n            default_sort_order_payload = (\n                try_enum_to_int(default_sort_order) if default_sort_order is not None else None\n            )\n\n        default_layout_payload: int = MISSING\n        if default_layout is not MISSING:\n            default_layout_payload = try_enum_to_int(default_layout)\n\n        options: dict[str, Any] = {\n            \"name\": name,\n            \"parent_id\": parent_id,\n            \"topic\": topic,\n            \"bitrate\": bitrate,\n            \"nsfw\": nsfw,\n            \"user_limit\": user_limit,\n            # note: not passing `position` as it already got updated before, if passed\n            \"permission_overwrites\": overwrites_payload,\n            \"rate_limit_per_user\": slowmode_delay,\n            \"default_thread_rate_limit_per_user\": default_thread_slowmode_delay,\n            \"type\": type_payload,\n            \"rtc_region\": rtc_region_payload,\n            \"video_quality_mode\": video_quality_mode_payload,\n            \"default_auto_archive_duration\": default_auto_archive_duration_payload,\n            \"flags\": flags_payload,\n            \"available_tags\": available_tags_payload,\n            \"default_reaction_emoji\": default_reaction_emoji_payload,\n            \"default_sort_order\": default_sort_order_payload,\n            \"default_forum_layout\": default_layout_payload,\n        }\n        options = {k: v for k, v in options.items() if v is not MISSING}\n\n        if options:\n            return await self._state.http.edit_channel(self.id, reason=reason, **options)\n        return None\n\n    def _fill_overwrites(self, data: GuildChannelPayload) -> None:\n        self._overwrites = []\n        everyone_index = 0\n        everyone_id = self.guild.id\n\n        for index, overridden in enumerate(data.get(\"permission_overwrites\", [])):\n            overwrite = _Overwrites(overridden)\n            self._overwrites.append(overwrite)\n\n            if overwrite.type == _Overwrites.MEMBER:\n                continue\n\n            if overwrite.id == everyone_id:\n                # the @everyone role is not guaranteed to be the first one\n                # in the list of permission overwrites, however the permission\n                # resolution code kind of requires that it is the first one in\n                # the list since it is special. So we need the index so we can\n                # swap it to be the first one.\n                everyone_index = index\n\n        # do the swap\n        tmp = self._overwrites\n        if tmp:\n            tmp[everyone_index], tmp[0] = tmp[0], tmp[everyone_index]\n\n    @property\n    def changed_roles(self) -> list[Role]:\n        r\"\"\":class:`list`\\[:class:`.Role`]: Returns a list of roles that have been overridden from\n        their default values in the :attr:`.Guild.roles` attribute.\n        \"\"\"\n        ret: list[Role] = []\n        g = self.guild\n        for overwrite in filter(lambda o: o.is_role(), self._overwrites):\n            role = g.get_role(overwrite.id)\n            if role is None:\n                continue\n\n            role = copy.copy(role)\n            role.permissions.handle_overwrite(overwrite.allow, overwrite.deny)\n            ret.append(role)\n        return ret\n\n    @property\n    def mention(self) -> str:\n        \"\"\":class:`str`: The string that allows you to mention the channel.\"\"\"\n        return f\"<#{self.id}>\"\n\n    @property\n    def created_at(self) -> datetime:\n        \"\"\":class:`datetime.datetime`: Returns the channel's creation time in UTC.\"\"\"\n        return utils.snowflake_time(self.id)\n\n    def overwrites_for(self, obj: Role | User) -> PermissionOverwrite:\n        \"\"\"Returns the channel-specific overwrites for a member or a role.\n\n        Parameters\n        ----------\n        obj: :class:`.Role` | :class:`.abc.User`\n            The role or user denoting\n            whose overwrite to get.\n\n        Returns\n        -------\n        :class:`~disnake.PermissionOverwrite`\n            The permission overwrites for this object.\n        \"\"\"\n        predicate: Callable[[_Overwrites], bool]\n        if isinstance(obj, User):\n            predicate = lambda p: p.is_member()\n        elif isinstance(obj, Role):\n            predicate = lambda p: p.is_role()\n        else:\n            predicate = lambda p: True\n\n        for overwrite in filter(predicate, self._overwrites):\n            if overwrite.id == obj.id:\n                allow = Permissions(overwrite.allow)\n                deny = Permissions(overwrite.deny)\n                return PermissionOverwrite.from_pair(allow, deny)\n\n        return PermissionOverwrite()\n\n    @property\n    def overwrites(self) -> dict[Role | Member, PermissionOverwrite]:\n        r\"\"\"Returns all of the channel's overwrites.\n\n        This is returned as a dictionary where the key contains the target which\n        can be either a :class:`~disnake.Role` or a :class:`~disnake.Member` and the value is the\n        overwrite as a :class:`~disnake.PermissionOverwrite`.\n\n        Returns\n        -------\n        :class:`dict`\\[:class:`~disnake.Role` | :class:`~disnake.Member`, :class:`~disnake.PermissionOverwrite`]\n            The channel's permission overwrites.\n        \"\"\"\n        ret = {}\n        for ow in self._overwrites:\n            allow = Permissions(ow.allow)\n            deny = Permissions(ow.deny)\n            overwrite = PermissionOverwrite.from_pair(allow, deny)\n            target = None\n\n            if ow.is_role():\n                target = self.guild.get_role(ow.id)\n            elif ow.is_member():\n                target = self.guild.get_member(ow.id)\n\n            # TODO: There is potential data loss here in the non-chunked\n            # case, i.e. target is None because get_member returned nothing.\n            # This can be fixed with a slight breaking change to the return type,\n            # i.e. adding disnake.Object to the list of it\n            # However, for now this is an acceptable compromise.\n            if target is not None:\n                ret[target] = overwrite\n        return ret\n\n    @property\n    def category(self) -> CategoryChannel | None:\n        \"\"\":class:`~disnake.CategoryChannel` | :data:`None`: The category this channel belongs to.\n\n        If there is no category then this is :data:`None`.\n        \"\"\"\n        if isinstance(self.guild, Object):\n            return None\n        return self.guild.get_channel(self.category_id)  # pyright: ignore[reportArgumentType, reportReturnType]\n\n    @property\n    def permissions_synced(self) -> bool:\n        \"\"\":class:`bool`: Whether or not the permissions for this channel are synced with the\n        category it belongs to.\n\n        If there is no category then this is ``False``.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        if self.category_id is None or isinstance(self.guild, Object):\n            return False\n\n        category = self.guild.get_channel(self.category_id)\n        return bool(category and category.overwrites == self.overwrites)\n\n    @property\n    def flags(self) -> ChannelFlags:\n        \"\"\":class:`.ChannelFlags`: The channel flags for this channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return ChannelFlags._from_value(self._flags)\n\n    @property\n    def jump_url(self) -> str:\n        \"\"\"A URL that can be used to jump to this channel.\n\n        .. versionadded:: 2.4\n\n        .. note::\n\n            This exists for all guild channels but may not be usable by the client for all guild channel types.\n        \"\"\"\n        return f\"https://discord.com/channels/{self.guild.id}/{self.id}\"\n\n    def _apply_implict_permissions(self, base: Permissions) -> None:\n        # if you can't send a message in a channel then you can't have certain\n        # permissions as well\n        if not base.send_messages:\n            base.send_tts_messages = False\n            base.send_voice_messages = False\n            base.send_polls = False\n            base.mention_everyone = False\n            base.embed_links = False\n            base.attach_files = False\n\n        # if you can't view a channel then you have no permissions there\n        if not base.view_channel:\n            denied = Permissions.all_channel()\n            base.value &= ~denied.value\n\n    def permissions_for(\n        self,\n        obj: Member | Role,\n        /,\n        *,\n        ignore_timeout: bool = MISSING,\n    ) -> Permissions:\n        \"\"\"Handles permission resolution for the :class:`~disnake.Member`\n        or :class:`~disnake.Role`.\n\n        This function takes into consideration the following cases:\n\n        - Guild owner\n        - Guild roles\n        - Channel overrides\n        - Member overrides\n        - Timeouts\n\n        If a :class:`~disnake.Role` is passed, then it checks the permissions\n        someone with that role would have, which is essentially:\n\n        - The default role permissions\n        - The permissions of the role used as a parameter\n        - The default role permission overwrites\n        - The permission overwrites of the role used as a parameter\n\n        .. note::\n            If the channel originated from an :class:`.Interaction` and\n            the :attr:`.guild` attribute is unavailable, such as with\n            user-installed applications in guilds, this method will not work\n            due to an API limitation.\n            Consider using :attr:`.Interaction.permissions` or :attr:`~.Interaction.app_permissions` instead.\n\n        .. versionchanged:: 2.0\n            The object passed in can now be a role object.\n\n        Parameters\n        ----------\n        obj: :class:`~disnake.Member` | :class:`~disnake.Role`\n            The object to resolve permissions for. This could be either\n            a member or a role. If it's a role then member overwrites\n            are not computed.\n        ignore_timeout: :class:`bool`\n            Whether or not to ignore the user's timeout.\n            Defaults to ``False``.\n\n            .. versionadded:: 2.4\n\n            .. note::\n\n                This only applies to :class:`~disnake.Member` objects.\n\n            .. versionchanged:: 2.6\n\n                The default was changed to ``False``.\n\n        Raises\n        ------\n        TypeError\n            ``ignore_timeout`` is only supported for :class:`~disnake.Member` objects.\n\n        Returns\n        -------\n        :class:`~disnake.Permissions`\n            The resolved permissions for the member or role.\n        \"\"\"\n        # The current cases can be explained as:\n        # Guild owner get all permissions -- no questions asked. Otherwise...\n        # The @everyone role gets the first application.\n        # After that, the applied roles that the user has in the channel\n        # (or otherwise) are then OR'd together.\n        # After the role permissions are resolved, the member permissions\n        # have to take into effect.\n        # After all that is done.. you have to do the following:\n\n        # The operation first takes into consideration the denied\n        # and then the allowed.\n\n        # Timeouted users have only view_channel and read_message_history\n        # if they already have them.\n        if ignore_timeout is not MISSING and isinstance(obj, Role):\n            msg = \"ignore_timeout is only supported for disnake.Member objects\"\n            raise TypeError(msg)\n\n        if ignore_timeout is MISSING:\n            ignore_timeout = False\n\n        if self.guild.owner_id == obj.id:\n            return Permissions.all()\n\n        default = self.guild.default_role\n        base = Permissions(default.permissions.value)\n\n        # Handle the role case first\n        if isinstance(obj, Role):\n            base.value |= obj._permissions\n\n            if base.administrator:\n                return Permissions.all()\n\n            # Apply @everyone allow/deny first since it's special\n            try:\n                maybe_everyone = self._overwrites[0]\n                if maybe_everyone.id == self.guild.id:\n                    base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n            except IndexError:\n                pass\n\n            if obj.is_default():\n                return base\n\n            overwrite = utils.get(self._overwrites, type=_Overwrites.ROLE, id=obj.id)\n            if overwrite is not None:\n                base.handle_overwrite(overwrite.allow, overwrite.deny)\n\n            return base\n\n        roles = obj._roles\n        get_role = self.guild.get_role\n\n        # Apply guild roles that the member has.\n        for role_id in roles:\n            role = get_role(role_id)\n            if role is not None:\n                base.value |= role._permissions\n\n        # Guild-wide Administrator -> True for everything\n        # Bypass all channel-specific overrides\n        if base.administrator:\n            return Permissions.all()\n\n        # Apply @everyone allow/deny first since it's special\n        try:\n            maybe_everyone = self._overwrites[0]\n            if maybe_everyone.id == self.guild.id:\n                base.handle_overwrite(allow=maybe_everyone.allow, deny=maybe_everyone.deny)\n                remaining_overwrites = self._overwrites[1:]\n            else:\n                remaining_overwrites = self._overwrites\n        except IndexError:\n            remaining_overwrites = self._overwrites\n\n        denies = 0\n        allows = 0\n\n        # Apply channel specific role permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_role() and roles.has(overwrite.id):\n                denies |= overwrite.deny\n                allows |= overwrite.allow\n\n        base.handle_overwrite(allow=allows, deny=denies)\n\n        # Apply member specific permission overwrites\n        for overwrite in remaining_overwrites:\n            if overwrite.is_member() and overwrite.id == obj.id:\n                base.handle_overwrite(allow=overwrite.allow, deny=overwrite.deny)\n                break\n\n        # if you have a timeout then you can't have any permissions\n        # except read messages and read message history\n        if not ignore_timeout and obj.current_timeout:\n            allowed = Permissions(view_channel=True, read_message_history=True)\n            base.value &= allowed.value\n\n        return base\n\n    async def delete(self, *, reason: str | None = None) -> None:\n        \"\"\"|coro|\n\n        Deletes the channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to do this.\n\n        Parameters\n        ----------\n        reason: :class:`str` | :data:`None`\n            The reason for deleting this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to delete the channel.\n        NotFound\n            The channel was not found or was already deleted.\n        HTTPException\n            Deleting the channel failed.\n        \"\"\"\n        await self._state.http.delete_channel(self.id, reason=reason)\n\n    @overload\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        overwrite: PermissionOverwrite | None = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    @_overload_with_permissions\n    async def set_permissions(\n        self,\n        target: Member | Role,\n        *,\n        reason: str | None = ...,\n        add_reactions: bool | None = ...,\n        administrator: bool | None = ...,\n        attach_files: bool | None = ...,\n        ban_members: bool | None = ...,\n        bypass_slowmode: bool | None = ...,\n        change_nickname: bool | None = ...,\n        connect: bool | None = ...,\n        create_events: bool | None = ...,\n        create_forum_threads: bool | None = ...,\n        create_guild_expressions: bool | None = ...,\n        create_instant_invite: bool | None = ...,\n        create_private_threads: bool | None = ...,\n        create_public_threads: bool | None = ...,\n        deafen_members: bool | None = ...,\n        embed_links: bool | None = ...,\n        external_emojis: bool | None = ...,\n        external_stickers: bool | None = ...,\n        kick_members: bool | None = ...,\n        manage_channels: bool | None = ...,\n        manage_emojis: bool | None = ...,\n        manage_emojis_and_stickers: bool | None = ...,\n        manage_events: bool | None = ...,\n        manage_guild: bool | None = ...,\n        manage_guild_expressions: bool | None = ...,\n        manage_messages: bool | None = ...,\n        manage_nicknames: bool | None = ...,\n        manage_permissions: bool | None = ...,\n        manage_roles: bool | None = ...,\n        manage_threads: bool | None = ...,\n        manage_webhooks: bool | None = ...,\n        mention_everyone: bool | None = ...,\n        moderate_members: bool | None = ...,\n        move_members: bool | None = ...,\n        mute_members: bool | None = ...,\n        pin_messages: bool | None = ...,\n        priority_speaker: bool | None = ...,\n        read_message_history: bool | None = ...,\n        read_messages: bool | None = ...,\n        request_to_speak: bool | None = ...,\n        send_messages: bool | None = ...,\n        send_messages_in_threads: bool | None = ...,\n        send_polls: bool | None = ...,\n        send_tts_messages: bool | None = ...,\n        send_voice_messages: bool | None = ...,\n        speak: bool | None = ...,\n        start_embedded_activities: bool | None = ...,\n        stream: bool | None = ...,\n        use_application_commands: bool | None = ...,\n        use_embedded_activities: bool | None = ...,\n        use_external_apps: bool | None = ...,\n        use_external_emojis: bool | None = ...,\n        use_external_sounds: bool | None = ...,\n        use_external_stickers: bool | None = ...,\n        use_slash_commands: bool | None = ...,\n        use_soundboard: bool | None = ...,\n        use_voice_activation: bool | None = ...,\n        view_audit_log: bool | None = ...,\n        view_channel: bool | None = ...,\n        view_creator_monetization_analytics: bool | None = ...,\n        view_guild_insights: bool | None = ...,\n    ) -> None: ...\n\n    async def set_permissions(\n        self,\n        target,\n        *,\n        overwrite: PermissionOverwrite | None = MISSING,\n        reason: str | None = None,\n        **permissions,\n    ) -> None:\n        \"\"\"|coro|\n\n        Sets the channel specific permission overwrites for a target in the\n        channel.\n\n        The ``target`` parameter should either be a :class:`.Member` or a\n        :class:`.Role` that belongs to guild.\n\n        The ``overwrite`` parameter, if given, must either be :data:`None` or\n        :class:`.PermissionOverwrite`. For convenience, you can pass in\n        keyword arguments denoting :class:`.Permissions` attributes. If this is\n        done, then you cannot mix the keyword arguments with the ``overwrite``\n        parameter.\n\n        If the ``overwrite`` parameter is :data:`None`, then the permission\n        overwrites are deleted.\n\n        You must have :attr:`.Permissions.manage_roles` permission to do this.\n\n        .. note::\n\n            This method *replaces* the old overwrites with the ones given.\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` instead of ``InvalidArgument``.\n\n        Examples\n        --------\n        Setting allow and deny: ::\n\n            await message.channel.set_permissions(message.author, view_channel=True,\n                                                                  send_messages=False)\n\n        Deleting overwrites ::\n\n            await channel.set_permissions(member, overwrite=None)\n\n        Using :class:`.PermissionOverwrite` ::\n\n            overwrite = disnake.PermissionOverwrite()\n            overwrite.send_messages = False\n            overwrite.view_channel = True\n            await channel.set_permissions(member, overwrite=overwrite)\n\n        Parameters\n        ----------\n        target: :class:`.Member` | :class:`.Role`\n            The member or role to overwrite permissions for.\n        overwrite: :class:`.PermissionOverwrite` | :data:`None`\n            The permissions to allow and deny to the target, or :data:`None` to\n            delete the overwrite.\n        **permissions\n            A keyword argument list of permissions to set for ease of use.\n            Cannot be mixed with ``overwrite``.\n        reason: :class:`str` | :data:`None`\n            The reason for doing this action. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to edit channel specific permissions.\n        HTTPException\n            Editing channel specific permissions failed.\n        NotFound\n            The role or member being edited is not part of the guild.\n        TypeError\n            ``overwrite`` is invalid,\n            the target type was not :class:`.Role` or :class:`.Member`,\n            both keyword arguments and ``overwrite`` were provided,\n            or invalid permissions were provided as keyword arguments.\n        \"\"\"\n        http = self._state.http\n\n        if isinstance(target, User):\n            perm_type = _Overwrites.MEMBER\n        elif isinstance(target, Role):\n            perm_type = _Overwrites.ROLE\n        else:\n            msg = \"target parameter must be either Member or Role\"\n            raise TypeError(msg)\n\n        if overwrite is MISSING:\n            if len(permissions) == 0:\n                msg = \"No overwrite provided.\"\n                raise TypeError(msg)\n            try:\n                overwrite = PermissionOverwrite(**permissions)\n            except (ValueError, TypeError) as e:\n                msg = \"Invalid permissions given to keyword arguments.\"\n                raise TypeError(msg) from e\n        else:\n            if len(permissions) > 0:\n                msg = \"Cannot mix overwrite and keyword arguments.\"\n                raise TypeError(msg)\n\n        # TODO: wait for event\n\n        if overwrite is None:\n            await http.delete_channel_permissions(self.id, target.id, reason=reason)\n        elif isinstance(overwrite, PermissionOverwrite):\n            (allow, deny) = overwrite.pair()\n            await http.edit_channel_permissions(\n                self.id, target.id, allow.value, deny.value, perm_type, reason=reason\n            )\n        else:\n            msg = \"Invalid overwrite type provided.\"\n            raise TypeError(msg)\n\n    async def _clone_impl(\n        self,\n        base_attrs: dict[str, Any],\n        *,\n        name: str | None = None,\n        category: Snowflake | None = MISSING,\n        overwrites: Mapping[Role | Member, PermissionOverwrite] = MISSING,\n        reason: str | None = None,\n    ) -> Self:\n        # if the overwrites are MISSING, defaults to the\n        # original permissions of the channel\n        overwrites_payload: list[PermissionOverwritePayload]\n        if overwrites is not MISSING:\n            if not isinstance(overwrites, dict):\n                msg = \"overwrites parameter expects a dict.\"\n                raise TypeError(msg)\n\n            overwrites_payload = []\n            for target, perm in overwrites.items():\n                if not isinstance(perm, PermissionOverwrite):\n                    msg = f\"Expected PermissionOverwrite, received {perm.__class__.__name__}\"\n                    raise TypeError(msg)\n\n                allow, deny = perm.pair()\n                payload: PermissionOverwritePayload = {\n                    \"allow\": str(allow.value),\n                    \"deny\": str(deny.value),\n                    \"id\": target.id,\n                    \"type\": (_Overwrites.ROLE if isinstance(target, Role) else _Overwrites.MEMBER),\n                }\n                overwrites_payload.append(payload)\n        else:\n            overwrites_payload = [x._asdict() for x in self._overwrites]\n        base_attrs[\"permission_overwrites\"] = overwrites_payload\n        if category is not MISSING:\n            base_attrs[\"parent_id\"] = category.id if category else None\n        else:\n            # if no category was given don't change the category\n            base_attrs[\"parent_id\"] = self.category_id\n        base_attrs[\"name\"] = name or self.name\n        channel_type = base_attrs.get(\"type\") or self.type.value\n        guild_id = self.guild.id\n        cls = self.__class__\n        data = await self._state.http.create_channel(\n            guild_id, channel_type, reason=reason, **base_attrs\n        )\n        obj = cls(state=self._state, guild=self.guild, data=data)\n\n        # temporarily add it to the cache\n        self.guild._channels[obj.id] = obj  # pyright: ignore[reportArgumentType]\n        return obj\n\n    async def clone(self, *, name: str | None = None, reason: str | None = None) -> Self:\n        \"\"\"|coro|\n\n        Clones this channel. This creates a channel with the same properties\n        as this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. versionadded:: 1.1\n\n        Parameters\n        ----------\n        name: :class:`str` | :data:`None`\n            The name of the new channel. If not provided, defaults to this channel name.\n        reason: :class:`str` | :data:`None`\n            The reason for cloning this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have the proper permissions to create this channel.\n        HTTPException\n            Creating the channel failed.\n\n        Returns\n        -------\n        :class:`.abc.GuildChannel`\n            The channel that was created.\n        \"\"\"\n        raise NotImplementedError\n\n    @overload\n    async def move(\n        self,\n        *,\n        beginning: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        end: bool,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        before: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    @overload\n    async def move(\n        self,\n        *,\n        after: Snowflake,\n        offset: int = ...,\n        category: Snowflake | None = ...,\n        sync_permissions: bool = ...,\n        reason: str | None = ...,\n    ) -> None: ...\n\n    async def move(self, **kwargs: Any) -> None:\n        \"\"\"|coro|\n\n        A rich interface to help move a channel relative to other channels.\n\n        If exact position movement is required, ``edit`` should be used instead.\n\n        You must have :attr:`.Permissions.manage_channels` permission to\n        do this.\n\n        .. note::\n\n            Voice channels will always be sorted below text channels.\n            This is a Discord limitation.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Raises :exc:`TypeError` or :exc:`ValueError` instead of ``InvalidArgument``.\n\n        Parameters\n        ----------\n        beginning: :class:`bool`\n            Whether to move the channel to the beginning of the\n            channel list (or category if given).\n            This is mutually exclusive with ``end``, ``before``, and ``after``.\n        end: :class:`bool`\n            Whether to move the channel to the end of the\n            channel list (or category if given).\n            This is mutually exclusive with ``beginning``, ``before``, and ``after``.\n        before: :class:`.abc.Snowflake`\n            The channel that should be before our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``after``.\n        after: :class:`.abc.Snowflake`\n            The channel that should be after our current channel.\n            This is mutually exclusive with ``beginning``, ``end``, and ``before``.\n        offset: :class:`int`\n            The number of channels to offset the move by. For example,\n            an offset of ``2`` with ``beginning=True`` would move\n            it 2 after the beginning. A positive number moves it below\n            while a negative number moves it above. Note that this\n            number is relative and computed after the ``beginning``,\n            ``end``, ``before``, and ``after`` parameters.\n        category: :class:`.abc.Snowflake` | :data:`None`\n            The category to move this channel under.\n            If :data:`None` is given then it moves it out of the category.\n            This parameter is ignored if moving a category channel.\n        sync_permissions: :class:`bool`\n            Whether to sync the permissions with the category (if given).\n        reason: :class:`str` | :data:`None`\n            The reason for moving this channel. Shows up on the audit log.\n\n        Raises\n        ------\n        Forbidden\n            You do not have permissions to move the channel.\n        HTTPException\n            Moving the channel failed.\n        TypeError\n            A bad mix of arguments were passed.\n        ValueError\n            An invalid position was given.\n        \"\"\"\n        if not kwargs:\n            return\n\n        beginning, end = kwargs.get(\"beginning\"), kwargs.get(\"end\")\n        before, after = kwargs.get(\"before\"), kwargs.get(\"after\")\n        offset = kwargs.get(\"offset\", 0)\n        if sum(bool(a) for a in (beginning, end, before, after)) > 1:\n            msg = \"Only one of [before, after, end, beginning] can be used.\"\n            raise TypeError(msg)\n\n        bucket = self._sorting_bucket\n        parent_id = kwargs.get(\"category\", MISSING)\n        if parent_id not in (MISSING, None):\n            parent_id = parent_id.id\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == parent_id\n            ]\n        else:\n            channels = [\n                ch\n                for ch in self.guild.channels\n                if ch._sorting_bucket == bucket and ch.category_id == self.category_id\n            ]\n\n        channels.sort(key=lambda c: (c.position, c.id))\n        channels = cast(\"list[GuildChannel]\", channels)\n\n        try:\n            # Try to remove ourselves from the channel list\n            channels.remove(self)\n        except ValueError:\n            # If we're not there then it's probably due to not being in the category\n            pass\n\n        index = None\n        if beginning:\n            index = 0\n        elif end:\n            index = len(channels)\n        elif before:\n            index = next((i for i, c in enumerate(channels) if c.id == before.id), None)\n        elif after:\n            index = next((i + 1 for i, c in enumerate(channels) if c.id == after.id), None)\n\n        if index is None:\n            msg = \"Could not resolve appropriate move position\"\n            raise ValueError(msg)\n\n        channels.insert(max((index + offset), 0), self)\n        payload: list[ChannelPositionUpdatePayload] = []\n        lock_permissions = kwargs.get(\"sync_permissions\", False)\n        reason = kwargs.get(\"reason\")\n        for index, channel in enumerate(channels):\n            d: ChannelPositionUpdatePayload = {\"id\": channel.id, \"position\": index}\n            if parent_id is not MISSING and channel.id == self.id:\n                d.update(parent_id=parent_id, lock_permissions=lock_permissions)\n            payload.append(d)\n\n        await self._state.http.bulk_channel_update(self.guild.id, payload, reason=reason)\n\n    async def create_invite(\n        self,\n        *,\n        reason: str | None = None,\n        max_age: int = 0,\n        max_uses: int = 0,\n        temporary: bool = False,\n        unique: bool = True,\n        target_type: InviteTarget | None = None,\n        target_user: User | None = None,\n        target_application: Snowflake | PartyType | None = None,\n        guild_scheduled_event: GuildScheduledEvent | None = None,\n    ) -> Invite:\n        \"\"\"|coro|\n\n        Creates an instant invite from a text or voice channel.\n\n        You must have :attr:`.Permissions.create_instant_invite` permission to\n        do this.\n\n        Parameters\n        ----------\n        max_age: :class:`int`\n            How long the invite should last in seconds. If set to ``0``, then the invite\n            doesn't expire. Defaults to ``0``.\n        max_uses: :class:`int`\n            How many uses the invite could be used for. If it's 0 then there\n            are unlimited uses. Defaults to ``0``.\n        temporary: :class:`bool`\n            Whether the invite grants temporary membership\n            (i.e. they get kicked after they disconnect). Defaults to ``False``.\n        unique: :class:`bool`\n            Whether a unique invite URL should be created. Defaults to ``True``.\n            If this is set to ``False`` then it will return a previously created\n            invite.\n        target_type: :class:`.InviteTarget` | :data:`None`\n            The type of target for the voice channel invite, if any.\n\n            .. versionadded:: 2.0\n\n        target_user: :class:`User` | :data:`None`\n            The user whose stream to display for this invite, required if ``target_type`` is :attr:`.InviteTarget.stream`.\n            The user must be streaming in the channel.\n\n            .. versionadded:: 2.0\n\n        target_application: :class:`.Snowflake` | :data:`None`\n            The ID of the embedded application for the invite, required if ``target_type`` is :attr:`.InviteTarget.embedded_application`.\n\n            .. versionadded:: 2.0\n\n            .. versionchanged:: 2.9\n                ``PartyType`` is deprecated, and :class:`.Snowflake` should be used instead.\n\n        guild_scheduled_event: :class:`.GuildScheduledEvent` | :data:`None`\n            The guild scheduled event to include with the invite.\n\n            .. versionadded:: 2.3\n\n        reason: :class:`str` | :data:`None`\n            The reason for creating this invite. Shows up on the audit log.\n\n        Raises\n        ------\n        HTTPException\n            Invite creation failed.\n        NotFound\n            The channel that was passed is a category or an invalid channel.\n\n        Returns\n        -------\n        :class:`.Invite`\n            The newly created invite.\n        \"\"\"\n        if isinstance(target_application, PartyType):\n            utils.warn_deprecated(\n                \"PartyType is deprecated and will be removed in future version\",\n                stacklevel=2,\n            )\n            target_application = Object(target_application.value)\n        data = await self._state.http.create_invite(\n            self.id,\n            reason=reason,\n            max_age=max_age,\n            max_uses=max_uses,\n            temporary=temporary,\n            unique=unique,\n            target_type=try_enum_to_int(target_type),\n            target_user_id=target_user.id if target_user else None,\n            target_application_id=target_application.id if target_application else None,\n        )\n        invite = Invite.from_incomplete(data=data, state=self._state)\n        invite.guild_scheduled_event = guild_scheduled_event\n        return invite\n\n    async def invites(self) -> list[Invite]:\n        r\"\"\"|coro|\n\n        Returns a list of all active instant invites from this channel.\n\n        You must have :attr:`.Permissions.manage_channels` permission to use this.\n\n        Raises\n        ------\n        Forbidden\n            You do not have proper permissions to get the information.\n        HTTPException\n            An error occurred while fetching the information.\n\n        Returns\n        -------\n        :class:`list`\\[:class:`.Invite`]\n            The list of invites that are currently active.\n        \"\"\"\n        state = self._state\n        data = await state.http.invites_from_channel(self.id)\n        guild = self.guild\n        return [Invite(state=state, data=invite, channel=self, guild=guild) for invite in data]", "n_imports_parsed": 6, "n_files_resolved": 2, "n_chars_extracted": 44081}, "tests/test_mentions.py::20": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["AllowedMentions"], "enclosing_function": "test_classmethod_all", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_embeds.py::34": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_init_empty", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ext/commands/test_base_core.py::85": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Permissions", "commands"], "enclosing_function": "test_attrs", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_utils.py::362": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["asyncio", "mock", "pytest", "utils"], "enclosing_function": "test_maybe_coroutine", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_colour.py::19": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Colour", "pytest"], "enclosing_function": "test_str", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ui/test_select.py::34": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py"], "used_names": ["disnake", "mock", "pytest", "ui"], "enclosing_function": "test_invalid", "extracted_code": "# Source: disnake/__init__.py\n\"\"\"\n\n__title__ = \"disnake\"\n__author__ = \"Rapptz, EQUENOS\"\n__license__ = \"MIT\"\n__copyright__ = \"Copyright 2015-present Rapptz, 2021-present EQUENOS\"\n\n__path__ = __import__(\"pkgutil\").extend_path(__path__, __name__)\n\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 357}, "tests/ext/commands/test_params.py::150": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Any", "commands"], "enclosing_function": "test_valid", "extracted_code": "", "n_imports_parsed": 7, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_utils.py::391": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["asyncio", "pytest", "utils"], "enclosing_function": "test_sane_wait_for", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_flags.py::190": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": [], "enclosing_function": "test__eq__flag_value", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_embeds.py::75": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_len", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ext/commands/test_view.py::30": {"resolved_imports": ["disnake/ext/commands/errors.py", "disnake/ext/commands/view.py"], "used_names": ["StringView", "pytest"], "enclosing_function": "test_get_word", "extracted_code": "# Source: disnake/ext/commands/view.py\nclass StringView:\n    def __init__(self, buffer: str) -> None:\n        self.index = 0\n        self.buffer = buffer\n        self.end = len(buffer)\n        self.previous = 0\n\n    @property\n    def current(self) -> str | None:\n        return None if self.eof else self.buffer[self.index]\n\n    @property\n    def eof(self) -> bool:\n        return self.index >= self.end\n\n    def undo(self) -> None:\n        self.index = self.previous\n\n    def skip_ws(self) -> bool:\n        pos = 0\n        while not self.eof:\n            try:\n                current = self.buffer[self.index + pos]\n                if not current.isspace():\n                    break\n                pos += 1\n            except IndexError:\n                break\n\n        self.previous = self.index\n        self.index += pos\n        return self.previous != self.index\n\n    def skip_string(self, string: str) -> bool:\n        strlen = len(string)\n        if self.buffer[self.index : self.index + strlen] == string:\n            self.previous = self.index\n            self.index += strlen\n            return True\n        return False\n\n    def read_rest(self) -> str:\n        result = self.buffer[self.index :]\n        self.previous = self.index\n        self.index = self.end\n        return result\n\n    def read(self, n: int) -> str:\n        result = self.buffer[self.index : self.index + n]\n        self.previous = self.index\n        self.index += n\n        return result\n\n    def get(self) -> str | None:\n        try:\n            result = self.buffer[self.index + 1]\n        except IndexError:\n            result = None\n\n        self.previous = self.index\n        self.index += 1\n        return result\n\n    def get_word(self) -> str:\n        pos = 0\n        while not self.eof:\n            try:\n                current = self.buffer[self.index + pos]\n                if current.isspace():\n                    break\n                pos += 1\n            except IndexError:\n                break\n        self.previous = self.index\n        result = self.buffer[self.index : self.index + pos]\n        self.index += pos\n        return result\n\n    def get_quoted_word(self) -> str | None:\n        current = self.current\n        if current is None:\n            return None\n\n        close_quote = _quotes.get(current)\n        is_quoted = bool(close_quote)\n        if is_quoted:\n            result = []\n            _escaped_quotes = (current, close_quote)\n        else:\n            result = [current]\n            _escaped_quotes = _all_quotes\n\n        while not self.eof:\n            current = self.get()\n            if not current:\n                if is_quoted:\n                    # unexpected EOF\n                    raise ExpectedClosingQuoteError(str(close_quote))\n                return \"\".join(result)\n\n            # currently we accept strings in the format of \"hello world\"\n            # to embed a quote inside the string you must escape it: \"a \\\"world\\\"\"\n            if current == \"\\\\\":\n                next_char = self.get()\n                if not next_char:\n                    # string ends with \\ and no character after it\n                    if is_quoted:\n                        # if we're quoted then we're expecting a closing quote\n                        raise ExpectedClosingQuoteError(str(close_quote))\n                    # if we aren't then we just let it through\n                    return \"\".join(result)\n\n                if next_char in _escaped_quotes:\n                    # escaped quote\n                    result.append(next_char)\n                else:\n                    # different escape character, ignore it\n                    self.undo()\n                    result.append(current)\n                continue\n\n            if not is_quoted and current in _all_quotes:\n                # we aren't quoted\n                raise UnexpectedQuoteError(current)\n\n            # closing quote\n            if is_quoted and current == close_quote:\n                next_char = self.get()\n                valid_eof = not next_char or next_char.isspace()\n                if not valid_eof:\n                    raise InvalidEndOfQuotedStringError(str(next_char))\n\n                # we're quoted so it's okay\n                return \"\".join(result)\n\n            if current.isspace() and not is_quoted:\n                # end of word found\n                return \"\".join(result)\n\n            result.append(current)\n        return None\n\n    def __repr__(self) -> str:\n        return (\n            f\"<StringView pos: {self.index} prev: {self.previous} end: {self.end} eof: {self.eof}>\"\n        )", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 4595}, "tests/test_utils.py::104": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["mock", "pytest", "utils", "warnings"], "enclosing_function": "test_deprecated", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_embeds.py::212": {"resolved_imports": ["disnake/__init__.py", "disnake/embeds.py"], "used_names": ["Embed"], "enclosing_function": "test_image_init", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_object.py::13": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Object", "pytest"], "enclosing_function": "test_init", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_utils.py::127": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["mock", "os", "pytest", "sys", "utils", "warnings"], "enclosing_function": "test_deprecated_skip", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_permissions.py::23": {"resolved_imports": ["disnake/permissions.py"], "used_names": ["Permissions"], "enclosing_function": "test_init_permissions_keyword_arguments_with_aliases", "extracted_code": "# Source: disnake/permissions.py\nclass Permissions(BaseFlags):\n    \"\"\"Wraps up the Discord permission value.\n\n    The properties provided are two way. You can set and retrieve individual\n    bits using the properties as if they were regular bools. This allows\n    you to edit permissions.\n\n    To construct an object you can pass keyword arguments denoting the permissions\n    to enable or disable.\n    Arguments are applied in order, which notably also means that supplying a flag\n    and its alias will make whatever comes last overwrite the first one; as an example,\n    ``Permissions(external_emojis=True, use_external_emojis=False)`` and\n    ``Permissions(use_external_emojis=True, external_emojis=False)``\n    both result in the same permissions value (``0``).\n\n    .. versionchanged:: 1.3\n        You can now use keyword arguments to initialize :class:`Permissions`\n        similar to :meth:`update`.\n\n    .. collapse:: operations\n\n        .. describe:: x == y\n\n            Checks if two permissions are equal.\n        .. describe:: x != y\n\n            Checks if two permissions are not equal.\n        .. describe:: x <= y\n\n            Checks if a permission is a subset of another permission.\n        .. describe:: x >= y\n\n            Checks if a permission is a superset of another permission.\n        .. describe:: x < y\n\n            Checks if a permission is a strict subset of another permission.\n        .. describe:: x > y\n\n            Checks if a permission is a strict superset of another permission.\n        .. describe:: x | y, x |= y\n\n            Returns a new Permissions instance with all enabled permissions from both x and y.\n            (Using ``|=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: x & y, x &= y\n\n            Returns a new Permissions instance with only permissions enabled on both x and y.\n            (Using ``&=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: x ^ y, x ^= y\n\n            Returns a new Permissions instance with only permissions enabled on one of x or y, but not both.\n            (Using ``^=`` will update in place).\n\n            .. versionadded:: 2.6\n        .. describe:: ~x\n\n            Returns a new Permissions instance with all permissions from x inverted.\n\n            .. versionadded:: 2.6\n        .. describe:: hash(x)\n\n               Return the permission's hash.\n        .. describe:: iter(x)\n\n               Returns an iterator of ``(perm, value)`` pairs. This allows it\n               to be, for example, constructed as a dict or a list of pairs.\n               Note that aliases are not shown.\n\n\n        Additionally supported are a few operations on class attributes.\n\n        .. describe:: Permissions.y | Permissions.z, Permissions(y=True) | Permissions.z\n\n            Returns a Permissions instance with all provided permissions enabled.\n\n            .. versionadded:: 2.6\n        .. describe:: ~Permissions.y\n\n            Returns a Permissions instance with all permissions except ``y`` inverted from their default value.\n\n            .. versionadded:: 2.6\n\n    Attributes\n    ----------\n    value: :class:`int`\n        The raw value. This value is a bit array field of a 53-bit integer\n        representing the currently available permissions. You should query\n        permissions via the properties rather than using this raw value.\n    \"\"\"\n\n    __slots__ = ()\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        permissions: int = 0,\n        *,\n        add_reactions: bool = ...,\n        administrator: bool = ...,\n        attach_files: bool = ...,\n        ban_members: bool = ...,\n        bypass_slowmode: bool = ...,\n        change_nickname: bool = ...,\n        connect: bool = ...,\n        create_events: bool = ...,\n        create_forum_threads: bool = ...,\n        create_guild_expressions: bool = ...,\n        create_instant_invite: bool = ...,\n        create_private_threads: bool = ...,\n        create_public_threads: bool = ...,\n        deafen_members: bool = ...,\n        embed_links: bool = ...,\n        external_emojis: bool = ...,\n        external_stickers: bool = ...,\n        kick_members: bool = ...,\n        manage_channels: bool = ...,\n        manage_emojis: bool = ...,\n        manage_emojis_and_stickers: bool = ...,\n        manage_events: bool = ...,\n        manage_guild: bool = ...,\n        manage_guild_expressions: bool = ...,\n        manage_messages: bool = ...,\n        manage_nicknames: bool = ...,\n        manage_permissions: bool = ...,\n        manage_roles: bool = ...,\n        manage_threads: bool = ...,\n        manage_webhooks: bool = ...,\n        mention_everyone: bool = ...,\n        moderate_members: bool = ...,\n        move_members: bool = ...,\n        mute_members: bool = ...,\n        pin_messages: bool = ...,\n        priority_speaker: bool = ...,\n        read_message_history: bool = ...,\n        read_messages: bool = ...,\n        request_to_speak: bool = ...,\n        send_messages: bool = ...,\n        send_messages_in_threads: bool = ...,\n        send_polls: bool = ...,\n        send_tts_messages: bool = ...,\n        send_voice_messages: bool = ...,\n        speak: bool = ...,\n        start_embedded_activities: bool = ...,\n        stream: bool = ...,\n        use_application_commands: bool = ...,\n        use_embedded_activities: bool = ...,\n        use_external_apps: bool = ...,\n        use_external_emojis: bool = ...,\n        use_external_sounds: bool = ...,\n        use_external_stickers: bool = ...,\n        use_slash_commands: bool = ...,\n        use_soundboard: bool = ...,\n        use_voice_activation: bool = ...,\n        view_audit_log: bool = ...,\n        view_channel: bool = ...,\n        view_creator_monetization_analytics: bool = ...,\n        view_guild_insights: bool = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def __init__(\n        self,\n        permissions: int = 0,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def __init__(self, permissions: int = 0, **kwargs: bool) -> None:\n        if not isinstance(permissions, int):\n            msg = f\"Expected int parameter, received {permissions.__class__.__name__} instead.\"\n            raise TypeError(msg)\n\n        self.value = permissions\n        for key, value in kwargs.items():\n            if key not in self.VALID_FLAGS:\n                msg = f\"{key!r} is not a valid permission name.\"\n                raise TypeError(msg)\n            setattr(self, key, value)\n\n    def is_subset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if self has the same or fewer permissions as other.\"\"\"\n        if isinstance(other, Permissions):\n            return (self.value & other.value) == self.value\n        else:\n            msg = f\"cannot compare {self.__class__.__name__} with {other.__class__.__name__}\"\n            raise TypeError(msg)\n\n    def is_superset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if self has the same or more permissions as other.\"\"\"\n        if isinstance(other, Permissions):\n            return (self.value | other.value) == self.value\n        else:\n            msg = f\"cannot compare {self.__class__.__name__} with {other.__class__.__name__}\"\n            raise TypeError(msg)\n\n    def is_strict_subset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if the permissions on self are a strict subset of those on other.\"\"\"\n        return self.is_subset(other) and self != other\n\n    def is_strict_superset(self, other: Permissions) -> bool:\n        \"\"\"Returns ``True`` if the permissions on self are a strict superset of those on other.\"\"\"\n        return self.is_superset(other) and self != other\n\n    # the parent uses `Self` for the `other` typehint but we use `Permissions` here for backwards compat.\n    __le__ = is_subset\n    __ge__ = is_superset\n    __lt__ = is_strict_subset\n    __gt__ = is_strict_superset\n\n    @classmethod\n    @cached_creation\n    def none(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        permissions set to ``False``.\n        \"\"\"\n        return cls(0)\n\n    @classmethod\n    @cached_creation\n    def all(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        permissions set to ``True``.\n        \"\"\"\n        return cls(**dict.fromkeys(cls.VALID_FLAGS.keys(), True))\n\n    @classmethod\n    @cached_creation\n    def all_channel(cls) -> Self:\n        \"\"\"A :class:`Permissions` with all channel-specific permissions set to\n        ``True`` and the guild-specific ones set to ``False``. The guild-specific\n        permissions are currently:\n\n        - :attr:`create_guild_expressions`\n        - :attr:`manage_guild_expressions`\n        - :attr:`view_audit_log`\n        - :attr:`view_guild_insights`\n        - :attr:`view_creator_monetization_analytics`\n        - :attr:`manage_guild`\n        - :attr:`change_nickname`\n        - :attr:`manage_nicknames`\n        - :attr:`kick_members`\n        - :attr:`ban_members`\n        - :attr:`moderate_members`\n        - :attr:`administrator`\n\n        .. versionchanged:: 1.7\n           Added :attr:`stream`, :attr:`priority_speaker` and :attr:`use_slash_commands` permissions.\n\n        .. versionchanged:: 2.0\n           Added :attr:`create_public_threads`, :attr:`create_private_threads`, :attr:`manage_threads`,\n           :attr:`use_external_stickers`, :attr:`send_messages_in_threads` and\n           :attr:`request_to_speak` permissions.\n\n        .. versionchanged:: 2.3\n            Added :attr:`use_embedded_activities` permission.\n\n        .. versionchanged:: 2.9\n            Added :attr:`use_soundboard` and :attr:`send_voice_messages` permissions.\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_events` permission.\n        \"\"\"\n        instance = cls.all()\n        instance.update(\n            administrator=False,\n            ban_members=False,\n            change_nickname=False,\n            create_guild_expressions=False,\n            kick_members=False,\n            manage_guild=False,\n            manage_guild_expressions=False,\n            manage_nicknames=False,\n            moderate_members=False,\n            view_audit_log=False,\n            view_guild_insights=False,\n            view_creator_monetization_analytics=False,\n        )\n        return instance\n\n    @classmethod\n    @cached_creation\n    def general(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"General\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 1.7\n           Permission :attr:`read_messages` is now included in the general permissions, but\n           permissions :attr:`administrator`, :attr:`create_instant_invite`, :attr:`kick_members`,\n           :attr:`ban_members`, :attr:`change_nickname` and :attr:`manage_nicknames` are\n           no longer part of the general permissions.\n\n        .. versionchanged:: 2.9\n            Added :attr:`view_creator_monetization_analytics` permission.\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_guild_expressions` permission.\n        \"\"\"\n        return cls(\n            view_channel=True,\n            manage_channels=True,\n            manage_roles=True,\n            create_guild_expressions=True,\n            manage_guild_expressions=True,\n            view_audit_log=True,\n            view_guild_insights=True,\n            view_creator_monetization_analytics=True,\n            manage_webhooks=True,\n            manage_guild=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def membership(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Membership\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.3\n            Added :attr:`moderate_members` permission.\n        \"\"\"\n        return cls(\n            create_instant_invite=True,\n            change_nickname=True,\n            manage_nicknames=True,\n            kick_members=True,\n            ban_members=True,\n            moderate_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def text(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Text\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 1.7\n           Permission :attr:`read_messages` is no longer part of the text permissions.\n           Added :attr:`use_slash_commands` permission.\n\n        .. versionchanged:: 2.0\n           Added :attr:`create_public_threads`, :attr:`create_private_threads`, :attr:`manage_threads`,\n           :attr:`send_messages_in_threads` and :attr:`use_external_stickers` permissions.\n\n        .. versionchanged:: 2.9\n            Added :attr:`send_voice_messages` permission.\n\n        .. versionchanged:: 2.10\n            Moved :attr:`use_application_commands` permission to :attr:`apps`.\n            Added :attr:`send_polls` permission.\n\n        .. versionchanged:: 2.11\n            Added :attr:`pin_messages` permission.\n\n        .. versionchanged:: 2.12\n            Added :attr:`bypass_slowmode` permission.\n        \"\"\"\n        return cls(\n            send_messages=True,\n            send_messages_in_threads=True,\n            create_public_threads=True,\n            create_private_threads=True,\n            embed_links=True,\n            attach_files=True,\n            add_reactions=True,\n            use_external_emojis=True,\n            use_external_stickers=True,\n            mention_everyone=True,\n            manage_messages=True,\n            manage_threads=True,\n            read_message_history=True,\n            send_tts_messages=True,\n            send_voice_messages=True,\n            pin_messages=True,\n            send_polls=True,\n            bypass_slowmode=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def voice(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Voice\" permissions from the official Discord UI set to ``True``.\n\n        .. versionchanged:: 2.3\n            Added :attr:`use_embedded_activities` permission.\n\n        .. versionchanged:: 2.9\n            Added :attr:`use_soundboard` and :attr:`use_external_sounds` permissions.\n\n        .. versionchanged:: 2.10\n            Moved :attr:`use_embedded_activities` permission to :attr:`apps`.\n        \"\"\"\n        return cls(\n            connect=True,\n            speak=True,\n            stream=True,\n            use_soundboard=True,\n            use_external_sounds=True,\n            use_voice_activation=True,\n            priority_speaker=True,\n            mute_members=True,\n            deafen_members=True,\n            move_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def stage(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Stage Channel\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            request_to_speak=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def stage_moderator(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Stage Moderator\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            manage_channels=True,\n            mute_members=True,\n            move_members=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def apps(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Apps\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return cls(\n            use_application_commands=True,\n            use_embedded_activities=True,\n            use_external_apps=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def events(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Events\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 2.4\n\n        .. versionchanged:: 2.10\n            Added :attr:`create_events` permission.\n        \"\"\"\n        return cls(\n            create_events=True,\n            manage_events=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def advanced(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with all\n        \"Advanced\" permissions from the official Discord UI set to ``True``.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return cls(\n            administrator=True,\n        )\n\n    @classmethod\n    @cached_creation\n    def private_channel(cls) -> Self:\n        \"\"\"A factory method that creates a :class:`Permissions` with the\n        best representation of a PrivateChannel's permissions.\n\n        This exists to maintain compatibility with other channel types.\n\n        This is equivalent to :meth:`Permissions.text` with :attr:`~Permissions.view_channel` with the following set to False:\n\n        - :attr:`~Permissions.send_tts_messages`: You cannot send TTS messages in a DM.\n        - :attr:`~Permissions.manage_messages`: You cannot delete others' messages in a DM.\n        - :attr:`~Permissions.manage_threads`: You cannot manage threads in a DM.\n        - :attr:`~Permissions.send_messages_in_threads`: You cannot make threads in a DM.\n        - :attr:`~Permissions.create_public_threads`: You cannot make public threads in a DM.\n        - :attr:`~Permissions.create_private_threads`: You cannot make private threads in a DM.\n        - :attr:`~Permissions.bypass_slowmode`: You cannot enable slowmode in a DM.\n\n        .. versionadded:: 2.4\n        \"\"\"\n        base = cls.text()\n        base.read_messages = True\n        base.send_tts_messages = False\n        base.manage_messages = False\n        base.manage_threads = False\n        base.send_messages_in_threads = False\n        base.create_public_threads = False\n        base.create_private_threads = False\n        base.bypass_slowmode = False\n        return base\n\n    @overload\n    @_generated\n    def update(\n        self,\n        *,\n        add_reactions: bool = ...,\n        administrator: bool = ...,\n        attach_files: bool = ...,\n        ban_members: bool = ...,\n        bypass_slowmode: bool = ...,\n        change_nickname: bool = ...,\n        connect: bool = ...,\n        create_events: bool = ...,\n        create_forum_threads: bool = ...,\n        create_guild_expressions: bool = ...,\n        create_instant_invite: bool = ...,\n        create_private_threads: bool = ...,\n        create_public_threads: bool = ...,\n        deafen_members: bool = ...,\n        embed_links: bool = ...,\n        external_emojis: bool = ...,\n        external_stickers: bool = ...,\n        kick_members: bool = ...,\n        manage_channels: bool = ...,\n        manage_emojis: bool = ...,\n        manage_emojis_and_stickers: bool = ...,\n        manage_events: bool = ...,\n        manage_guild: bool = ...,\n        manage_guild_expressions: bool = ...,\n        manage_messages: bool = ...,\n        manage_nicknames: bool = ...,\n        manage_permissions: bool = ...,\n        manage_roles: bool = ...,\n        manage_threads: bool = ...,\n        manage_webhooks: bool = ...,\n        mention_everyone: bool = ...,\n        moderate_members: bool = ...,\n        move_members: bool = ...,\n        mute_members: bool = ...,\n        pin_messages: bool = ...,\n        priority_speaker: bool = ...,\n        read_message_history: bool = ...,\n        read_messages: bool = ...,\n        request_to_speak: bool = ...,\n        send_messages: bool = ...,\n        send_messages_in_threads: bool = ...,\n        send_polls: bool = ...,\n        send_tts_messages: bool = ...,\n        send_voice_messages: bool = ...,\n        speak: bool = ...,\n        start_embedded_activities: bool = ...,\n        stream: bool = ...,\n        use_application_commands: bool = ...,\n        use_embedded_activities: bool = ...,\n        use_external_apps: bool = ...,\n        use_external_emojis: bool = ...,\n        use_external_sounds: bool = ...,\n        use_external_stickers: bool = ...,\n        use_slash_commands: bool = ...,\n        use_soundboard: bool = ...,\n        use_voice_activation: bool = ...,\n        view_audit_log: bool = ...,\n        view_channel: bool = ...,\n        view_creator_monetization_analytics: bool = ...,\n        view_guild_insights: bool = ...,\n    ) -> None: ...\n\n    @overload\n    @_generated\n    def update(\n        self,\n    ) -> None: ...\n\n    @_overload_with_permissions\n    def update(self, **kwargs: bool) -> None:\n        \"\"\"Bulk updates this permission object.\n\n        Allows you to set multiple attributes by using keyword\n        arguments. The names must be equivalent to the properties\n        listed. Extraneous key/value pairs will be silently ignored.\n\n        Arguments are applied in order, similar to the constructor.\n\n        Parameters\n        ----------\n        **kwargs\n            A list of key/value pairs to bulk update permissions with.\n        \"\"\"\n        for key, value in kwargs.items():\n            if key in self.VALID_FLAGS:\n                setattr(self, key, value)\n\n    def handle_overwrite(self, allow: int, deny: int) -> None:\n        # Basically this is what's happening here.\n        # We have an original bit array, e.g. 1010\n        # Then we have another bit array that is 'denied', e.g. 1111\n        # And then we have the last one which is 'allowed', e.g. 0101\n        # We want original OP denied to end up resulting in\n        # whatever is in denied to be set to 0.\n        # So 1010 OP 1111 -> 0000\n        # Then we take this value and look at the allowed values.\n        # And whatever is allowed is set to 1.\n        # So 0000 OP2 0101 -> 0101\n        # The OP is base  & ~denied.\n        # The OP2 is base | allowed.\n        self.value = (self.value & ~deny) | allow\n\n    @flag_value\n    def create_instant_invite(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if the user can create instant invites.\"\"\"\n        return 1 << 0\n\n    @flag_value\n    def kick_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if the user can kick users from the guild.\"\"\"\n        return 1 << 1\n\n    @flag_value\n    def ban_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can ban users from the guild.\"\"\"\n        return 1 << 2\n\n    @flag_value\n    def administrator(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user is an administrator. This role overrides all other permissions.\n\n        This also bypasses all channel-specific overrides.\n        \"\"\"\n        return 1 << 3\n\n    @flag_value\n    def manage_channels(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit, delete, or create channels in the guild.\n\n        This also corresponds to the \"Manage Channel\" channel-specific override.\n        \"\"\"\n        return 1 << 4\n\n    @flag_value\n    def manage_guild(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit guild properties.\"\"\"\n        return 1 << 5\n\n    @flag_value\n    def add_reactions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can add reactions to messages.\"\"\"\n        return 1 << 6\n\n    @flag_value\n    def view_audit_log(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view the guild's audit log.\"\"\"\n        return 1 << 7\n\n    @flag_value\n    def priority_speaker(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can be more easily heard while talking.\"\"\"\n        return 1 << 8\n\n    @flag_value\n    def stream(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can stream in a voice channel.\"\"\"\n        return 1 << 9\n\n    @flag_value\n    def view_channel(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view all or specific channels.\n\n        .. versionadded:: 1.3\n\n        .. versionchanged:: 2.4\n            :attr:`~Permissions.read_messages` is now an alias of :attr:`~Permissions.view_channel`.\n        \"\"\"\n        return 1 << 10\n\n    @make_permission_alias(\"view_channel\")\n    def read_messages(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`view_channel`.\"\"\"\n        return 1 << 10\n\n    @flag_value\n    def send_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send messages from all or specific text channels\n        and create threads in forum/media channels.\n        \"\"\"\n        return 1 << 11\n\n    @make_permission_alias(\"send_messages\")\n    def create_forum_threads(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`send_messages`.\n\n        .. versionadded:: 2.5\n        \"\"\"\n        return 1 << 11\n\n    @flag_value\n    def send_tts_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send TTS messages from all or specific text channels.\"\"\"\n        return 1 << 12\n\n    @flag_value\n    def manage_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can delete messages in a text channel.\n\n        .. note::\n\n            Note that there are currently no ways to edit other people's messages.\n        \"\"\"\n        return 1 << 13\n\n    @flag_value\n    def embed_links(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's messages will automatically be embedded by Discord.\"\"\"\n        return 1 << 14\n\n    @flag_value\n    def attach_files(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send files in their messages.\"\"\"\n        return 1 << 15\n\n    @flag_value\n    def read_message_history(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can read a text channel's previous messages.\"\"\"\n        return 1 << 16\n\n    @flag_value\n    def mention_everyone(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's @everyone or @here will mention everyone in the text channel.\"\"\"\n        return 1 << 17\n\n    @flag_value\n    def external_emojis(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use emojis from other guilds.\"\"\"\n        return 1 << 18\n\n    @make_permission_alias(\"external_emojis\")\n    def use_external_emojis(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`external_emojis`.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 18\n\n    @flag_value\n    def view_guild_insights(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view the guild's insights.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 19\n\n    @flag_value\n    def connect(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can connect to a voice channel.\"\"\"\n        return 1 << 20\n\n    @flag_value\n    def speak(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can speak in a voice channel.\"\"\"\n        return 1 << 21\n\n    @flag_value\n    def mute_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can mute other users.\"\"\"\n        return 1 << 22\n\n    @flag_value\n    def deafen_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can deafen other users.\"\"\"\n        return 1 << 23\n\n    @flag_value\n    def move_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can move users between other voice channels.\"\"\"\n        return 1 << 24\n\n    @flag_value\n    def use_voice_activation(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use voice activation in voice channels.\"\"\"\n        return 1 << 25\n\n    @flag_value\n    def change_nickname(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can change their nickname in the guild.\"\"\"\n        return 1 << 26\n\n    @flag_value\n    def manage_nicknames(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can change other user's nickname in the guild.\"\"\"\n        return 1 << 27\n\n    @flag_value\n    def manage_roles(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create or edit roles less than their role's position.\n\n        This also corresponds to the \"Manage Permissions\" channel-specific override.\n        \"\"\"\n        return 1 << 28\n\n    @make_permission_alias(\"manage_roles\")\n    def manage_permissions(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_roles`.\n\n        .. versionadded:: 1.3\n        \"\"\"\n        return 1 << 28\n\n    @flag_value\n    def manage_webhooks(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create, edit, or delete webhooks.\"\"\"\n        return 1 << 29\n\n    @flag_value\n    def manage_guild_expressions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit or delete\n        emojis, stickers, and soundboard sounds created by all users.\n\n        See also :attr:`create_guild_expressions`.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 30\n\n    @make_permission_alias(\"manage_guild_expressions\")\n    def manage_emojis(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_guild_expressions`.\"\"\"\n        return 1 << 30\n\n    @make_permission_alias(\"manage_guild_expressions\")\n    def manage_emojis_and_stickers(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`manage_guild_expressions`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 30\n\n    @flag_value\n    def use_application_commands(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use application commands.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return 1 << 31\n\n    @make_permission_alias(\"use_application_commands\")\n    def use_slash_commands(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`use_application_commands`.\n\n        .. versionadded:: 1.7\n\n        .. versionchanged:: 2.6\n            Became an alias for :attr:`use_application_commands`.\n        \"\"\"\n        return 1 << 31\n\n    @flag_value\n    def request_to_speak(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can request to speak in a stage channel.\n\n        .. versionadded:: 1.7\n        \"\"\"\n        return 1 << 32\n\n    @flag_value\n    def manage_events(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can edit or delete guild scheduled events\n        created by all users.\n\n        See also :attr:`create_events`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 33\n\n    @flag_value\n    def manage_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can manage threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 34\n\n    @flag_value\n    def create_public_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create public threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 35\n\n    @flag_value\n    def create_private_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create private threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 36\n\n    @flag_value\n    def external_stickers(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use stickers from other guilds.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 37\n\n    @make_permission_alias(\"external_stickers\")\n    def use_external_stickers(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`external_stickers`.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 37\n\n    @flag_value\n    def send_messages_in_threads(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send messages in threads.\n\n        .. versionadded:: 2.0\n        \"\"\"\n        return 1 << 38\n\n    @flag_value\n    def use_embedded_activities(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use activities (applications\n        with the :attr:`~ApplicationFlags.embedded` flag) in a voice channel.\n\n        .. versionadded:: 2.6\n        \"\"\"\n        return 1 << 39\n\n    @make_permission_alias(\"use_embedded_activities\")\n    def start_embedded_activities(self) -> int:\n        \"\"\":class:`bool`: An alias for :attr:`use_embedded_activities`.\n\n        .. versionadded:: 2.3\n\n        .. versionchanged:: 2.6\n            Became an alias for :attr:`use_embedded_activities`.\n        \"\"\"\n        return 1 << 39\n\n    @flag_value\n    def moderate_members(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can perform limited moderation actions,\n        such as timeouts or editing members' flags.\n\n        .. versionadded:: 2.3\n        \"\"\"\n        return 1 << 40\n\n    @flag_value\n    def view_creator_monetization_analytics(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can view role subscription insights.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 41\n\n    @flag_value\n    def use_soundboard(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use the soundboard in voice channels.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 42\n\n    @flag_value\n    def create_guild_expressions(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create emojis, stickers,\n        and soundboard sounds, as well as edit and delete the ones they created.\n\n        See also :attr:`manage_guild_expressions`.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 43\n\n    @flag_value\n    def create_events(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can create guild scheduled events,\n        as well as edit and delete the ones they created.\n\n        See also :attr:`manage_events`.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 44\n\n    @flag_value\n    def use_external_sounds(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can use custom soundboard sounds from other guilds.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 45\n\n    @flag_value\n    def send_voice_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send voice messages.\n\n        .. versionadded:: 2.9\n        \"\"\"\n        return 1 << 46\n\n    @flag_value\n    def send_polls(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can send polls.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 49\n\n    @flag_value\n    def use_external_apps(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user's apps can send public responses.\n\n        If disabled, users can still use their user-installed applications, but the responses\n        will be forced ephemeral (i.e. only visible to them).\n        Only applies to user-installed apps that are not also installed to the guild.\n\n        .. versionadded:: 2.10\n        \"\"\"\n        return 1 << 50\n\n    @flag_value\n    def pin_messages(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can pin and unpin messages.\n\n        .. versionadded:: 2.11\n        \"\"\"\n        return 1 << 51\n\n    @flag_value\n    def bypass_slowmode(self) -> int:\n        \"\"\":class:`bool`: Returns ``True`` if a user can bypass slowmode restrictions.\n\n        Bots are unaffected by slowmode regardless of this permission.\n\n        .. versionadded:: 2.12\n        \"\"\"\n        return 1 << 52", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 35157}, "tests/ext/commands/test_slash_core.py::35": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_qualified_name", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ui/test_components.py::48": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py"], "used_names": ["pytest", "ui"], "enclosing_function": "test_id_property", "extracted_code": "# Source: disnake/__init__.py\nimport logging\n\nfrom . import abc as abc, opus as opus, ui as ui, utils as utils  # explicitly re-export modules\nfrom ._version import (\n    VersionInfo as VersionInfo,\n    __version__ as __version__,\n    version_info as version_info,\n)\nfrom .activity import *\nfrom .app_commands import *\nfrom .appinfo import *\nfrom .application_role_connection import *\n\nfrom .file import *\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\n\nfrom .flags import *\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\n\nfrom .guild import *\nfrom .guild_preview import *\nfrom .guild_scheduled_event import *\nfrom .i18n import *\nfrom .integrations import *\nfrom .interactions import *\nfrom .invite import *\nfrom .member import *\nfrom .mentions import *\nfrom .message import *\nfrom .object import *\nfrom .onboarding import *", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 1281}, "tests/ui/test_action_row.py::120": {"resolved_imports": ["disnake/__init__.py", "disnake/ui/__init__.py", "disnake/ui/_types.py", "disnake/ui/action_row.py"], "used_names": ["ActionRow"], "enclosing_function": "test_clear_items", "extracted_code": "", "n_imports_parsed": 8, "n_files_resolved": 4, "n_chars_extracted": 0}, "tests/test_onboarding.py::75": {"resolved_imports": ["disnake/__init__.py", "disnake/types/__init__.py", "disnake/types/onboarding.py"], "used_names": ["Onboarding", "onboarding"], "enclosing_function": "test_onboarding", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 3, "n_chars_extracted": 0}, "tests/ext/commands/test_core.py::65": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": ["assert_type", "commands"], "enclosing_function": "_test_typing_cls", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_utils.py::188": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["datetime", "pytest", "timedelta", "timezone", "utils"], "enclosing_function": "test_time_snowflake", "extracted_code": "", "n_imports_parsed": 17, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_slash_core.py::29": {"resolved_imports": ["disnake/ext/commands/__init__.py"], "used_names": [], "enclosing_function": "test_parent", "extracted_code": "", "n_imports_parsed": 1, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/test_object.py::25": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Object"], "enclosing_function": "test_hash", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}, "tests/ext/commands/test_base_core.py::86": {"resolved_imports": ["disnake/__init__.py", "disnake/ext/commands/__init__.py"], "used_names": ["Permissions", "commands"], "enclosing_function": "test_attrs", "extracted_code": "", "n_imports_parsed": 5, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/test_flags.py::111": {"resolved_imports": ["disnake/__init__.py", "disnake/flags.py"], "used_names": ["pytest", "re"], "enclosing_function": "test_flag_value_or", "extracted_code": "", "n_imports_parsed": 4, "n_files_resolved": 2, "n_chars_extracted": 0}, "tests/ext/commands/test_view.py::61": {"resolved_imports": ["disnake/ext/commands/errors.py", "disnake/ext/commands/view.py"], "used_names": ["ExpectedClosingQuoteError", "InvalidEndOfQuotedStringError", "StringView", "UnexpectedQuoteError", "pytest"], "enclosing_function": "test_get_quoted_word_raises", "extracted_code": "# Source: disnake/ext/commands/errors.py\nclass UnexpectedQuoteError(ArgumentParsingError):\n    \"\"\"An exception raised when the parser encounters a quote mark inside a non-quoted string.\n\n    This inherits from :exc:`ArgumentParsingError`.\n\n    Attributes\n    ----------\n    quote: :class:`str`\n        The quote mark that was found inside the non-quoted string.\n    \"\"\"\n\n    def __init__(self, quote: str) -> None:\n        self.quote: str = quote\n        super().__init__(f\"Unexpected quote mark, {quote!r}, in non-quoted string\")\n\nclass InvalidEndOfQuotedStringError(ArgumentParsingError):\n    \"\"\"An exception raised when a space is expected after the closing quote in a string\n    but a different character is found.\n\n    This inherits from :exc:`ArgumentParsingError`.\n\n    Attributes\n    ----------\n    char: :class:`str`\n        The character found instead of the expected string.\n    \"\"\"\n\n    def __init__(self, char: str) -> None:\n        self.char: str = char\n        super().__init__(f\"Expected space after closing quotation but received {char!r}\")\n\nclass ExpectedClosingQuoteError(ArgumentParsingError):\n    \"\"\"An exception raised when a quote character is expected but not found.\n\n    This inherits from :exc:`ArgumentParsingError`.\n\n    Attributes\n    ----------\n    close_quote: :class:`str`\n        The quote character expected.\n    \"\"\"\n\n    def __init__(self, close_quote: str) -> None:\n        self.close_quote: str = close_quote\n        super().__init__(f\"Expected closing {close_quote}.\")\n\n\n# Source: disnake/ext/commands/view.py\nclass StringView:\n    def __init__(self, buffer: str) -> None:\n        self.index = 0\n        self.buffer = buffer\n        self.end = len(buffer)\n        self.previous = 0\n\n    @property\n    def current(self) -> str | None:\n        return None if self.eof else self.buffer[self.index]\n\n    @property\n    def eof(self) -> bool:\n        return self.index >= self.end\n\n    def undo(self) -> None:\n        self.index = self.previous\n\n    def skip_ws(self) -> bool:\n        pos = 0\n        while not self.eof:\n            try:\n                current = self.buffer[self.index + pos]\n                if not current.isspace():\n                    break\n                pos += 1\n            except IndexError:\n                break\n\n        self.previous = self.index\n        self.index += pos\n        return self.previous != self.index\n\n    def skip_string(self, string: str) -> bool:\n        strlen = len(string)\n        if self.buffer[self.index : self.index + strlen] == string:\n            self.previous = self.index\n            self.index += strlen\n            return True\n        return False\n\n    def read_rest(self) -> str:\n        result = self.buffer[self.index :]\n        self.previous = self.index\n        self.index = self.end\n        return result\n\n    def read(self, n: int) -> str:\n        result = self.buffer[self.index : self.index + n]\n        self.previous = self.index\n        self.index += n\n        return result\n\n    def get(self) -> str | None:\n        try:\n            result = self.buffer[self.index + 1]\n        except IndexError:\n            result = None\n\n        self.previous = self.index\n        self.index += 1\n        return result\n\n    def get_word(self) -> str:\n        pos = 0\n        while not self.eof:\n            try:\n                current = self.buffer[self.index + pos]\n                if current.isspace():\n                    break\n                pos += 1\n            except IndexError:\n                break\n        self.previous = self.index\n        result = self.buffer[self.index : self.index + pos]\n        self.index += pos\n        return result\n\n    def get_quoted_word(self) -> str | None:\n        current = self.current\n        if current is None:\n            return None\n\n        close_quote = _quotes.get(current)\n        is_quoted = bool(close_quote)\n        if is_quoted:\n            result = []\n            _escaped_quotes = (current, close_quote)\n        else:\n            result = [current]\n            _escaped_quotes = _all_quotes\n\n        while not self.eof:\n            current = self.get()\n            if not current:\n                if is_quoted:\n                    # unexpected EOF\n                    raise ExpectedClosingQuoteError(str(close_quote))\n                return \"\".join(result)\n\n            # currently we accept strings in the format of \"hello world\"\n            # to embed a quote inside the string you must escape it: \"a \\\"world\\\"\"\n            if current == \"\\\\\":\n                next_char = self.get()\n                if not next_char:\n                    # string ends with \\ and no character after it\n                    if is_quoted:\n                        # if we're quoted then we're expecting a closing quote\n                        raise ExpectedClosingQuoteError(str(close_quote))\n                    # if we aren't then we just let it through\n                    return \"\".join(result)\n\n                if next_char in _escaped_quotes:\n                    # escaped quote\n                    result.append(next_char)\n                else:\n                    # different escape character, ignore it\n                    self.undo()\n                    result.append(current)\n                continue\n\n            if not is_quoted and current in _all_quotes:\n                # we aren't quoted\n                raise UnexpectedQuoteError(current)\n\n            # closing quote\n            if is_quoted and current == close_quote:\n                next_char = self.get()\n                valid_eof = not next_char or next_char.isspace()\n                if not valid_eof:\n                    raise InvalidEndOfQuotedStringError(str(next_char))\n\n                # we're quoted so it's okay\n                return \"\".join(result)\n\n            if current.isspace() and not is_quoted:\n                # end of word found\n                return \"\".join(result)\n\n            result.append(current)\n        return None\n\n    def __repr__(self) -> str:\n        return (\n            f\"<StringView pos: {self.index} prev: {self.previous} end: {self.end} eof: {self.eof}>\"\n        )", "n_imports_parsed": 3, "n_files_resolved": 2, "n_chars_extracted": 6104}, "tests/test_colour.py::41": {"resolved_imports": ["disnake/__init__.py"], "used_names": ["Colour", "pytest"], "enclosing_function": "test_from_rgb", "extracted_code": "", "n_imports_parsed": 3, "n_files_resolved": 1, "n_chars_extracted": 0}}}