feat(events): migrate parse_x events to Event subclasses

Migrate 18 remaining parse_x methods from ConnectionState to new Event subclasses following the established event migration pattern.

Created event files:
- audit_log.py: GuildAuditLogEntryCreate
- scheduled_event.py: GuildScheduledEvent{Create,Update,Delete,UserAdd,UserRemove}
- integration.py: GuildIntegrationsUpdate, Integration{Create,Update,Delete}
- stage_instance.py: StageInstance{Create,Update,Delete}
- voice.py: VoiceStateUpdate, VoiceServerUpdate, VoiceChannelStatusUpdate
- typing.py: TypingStart
- webhook.py: WebhooksUpdate

Changes to ConnectionState:
- Removed 18 parse_x methods
- Removed _get_typing_user helper (moved to typing.py)
- Cleaned up unused imports (AuditLogEntry, ScheduledEventStatus, _integration_factory, ScheduledEvent, StageInstance)
- Kept parse_guild_members_chunk (internal infrastructure)

Bug fixes:
- Fixed subscriber count decrement in GuildScheduledEventUserRemove

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: Paillat-dev

discord/app/state.py

@@ -46,15 +46,13 @@
 
 from .. import utils
 from ..activity import BaseActivity
-from ..audit_logs import AuditLogEntry
 from ..automod import AutoModRule
 from ..channel import *
 from ..channel import _channel_factory
 from ..emoji import AppEmoji, GuildEmoji
-from ..enums import ChannelType, InteractionType, ScheduledEventStatus, Status, try_enum
+from ..enums import ChannelType, InteractionType, Status, try_enum
 from ..flags import ApplicationFlags, Intents, MemberCacheFlags
 from ..guild import Guild
-from ..integrations import _integration_factory
 from ..interactions import Interaction
 from ..invite import Invite
 from ..member import Member
@@ -66,8 +64,6 @@
 from ..poll import Poll, PollAnswerCount
 from ..raw_models import *
 from ..role import Role
-from ..scheduled_events import ScheduledEvent
-from ..stage_instance import StageInstance
 from ..sticker import GuildSticker
 from ..threads import Thread, ThreadMember
 from ..ui.modal import Modal
@@ -531,23 +527,6 @@ async def _chunk_and_dispatch(self, guild, unavailable):
         else:
             self.dispatch("guild_join", guild)
 
-    def parse_guild_audit_log_entry_create(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is None:
-            _log.debug(
-                ("GUILD_AUDIT_LOG_ENTRY_CREATE referencing an unknown guild ID: %s. Discarding."),
-                data["guild_id"],
-            )
-            return
-        payload = RawAuditLogEntryEvent(data)
-        payload.guild = guild
-        self.dispatch("raw_audit_log_entry", payload)
-        user = self.get_user(payload.user_id)
-        if user is not None:
-            data.pop("guild_id")
-            entry = AuditLogEntry(users={data["user_id"]: user}, data=data, guild=guild)
-            self.dispatch("audit_log_entry", entry)
-
     def parse_guild_members_chunk(self, data) -> None:
         guild_id = int(data["guild_id"])
         guild = self._get_guild(guild_id)
@@ -569,306 +548,6 @@ def parse_guild_members_chunk(self, data) -> None:
         complete = data.get("chunk_index", 0) + 1 == data.get("chunk_count")
         self.process_chunk_requests(guild_id, data.get("nonce"), members, complete)
 
-    def parse_guild_scheduled_event_create(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is None:
-            _log.debug(
-                ("GUILD_SCHEDULED_EVENT_CREATE referencing an unknown guild ID: %s. Discarding."),
-                data["guild_id"],
-            )
-            return
-
-        creator = None if not data.get("creator", None) else guild.get_member(data.get("creator_id"))
-        scheduled_event = ScheduledEvent(state=self, guild=guild, creator=creator, data=data)
-        guild._add_scheduled_event(scheduled_event)
-        self.dispatch("scheduled_event_create", scheduled_event)
-
-    def parse_guild_scheduled_event_update(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is None:
-            _log.debug(
-                ("GUILD_SCHEDULED_EVENT_UPDATE referencing an unknown guild ID: %s. Discarding."),
-                data["guild_id"],
-            )
-            return
-
-        creator = None if not data.get("creator", None) else guild.get_member(data.get("creator_id"))
-        scheduled_event = ScheduledEvent(state=self, guild=guild, creator=creator, data=data)
-        old_event = guild.get_scheduled_event(int(data["id"]))
-        guild._add_scheduled_event(scheduled_event)
-        self.dispatch("scheduled_event_update", old_event, scheduled_event)
-
-    def parse_guild_scheduled_event_delete(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is None:
-            _log.debug(
-                ("GUILD_SCHEDULED_EVENT_DELETE referencing an unknown guild ID: %s. Discarding."),
-                data["guild_id"],
-            )
-            return
-
-        creator = None if not data.get("creator", None) else guild.get_member(data.get("creator_id"))
-        scheduled_event = ScheduledEvent(state=self, guild=guild, creator=creator, data=data)
-        scheduled_event.status = ScheduledEventStatus.canceled
-        guild._remove_scheduled_event(scheduled_event)
-        self.dispatch("scheduled_event_delete", scheduled_event)
-
-    def parse_guild_scheduled_event_user_add(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is None:
-            _log.debug(
-                ("GUILD_SCHEDULED_EVENT_USER_ADD referencing an unknown guild ID: %s. Discarding."),
-                data["guild_id"],
-            )
-            return
-
-        payload = RawScheduledEventSubscription(data, "USER_ADD")
-        payload.guild = guild
-        self.dispatch("raw_scheduled_event_user_add", payload)
-
-        member = guild.get_member(data["user_id"])
-        if member is not None:
-            event = guild.get_scheduled_event(data["guild_scheduled_event_id"])
-            if event:
-                event.subscriber_count += 1
-                guild._add_scheduled_event(event)
-                self.dispatch("scheduled_event_user_add", event, member)
-
-    def parse_guild_scheduled_event_user_remove(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is None:
-            _log.debug(
-                ("GUILD_SCHEDULED_EVENT_USER_REMOVE referencing an unknown guild ID: %s. Discarding."),
-                data["guild_id"],
-            )
-            return
-
-        payload = RawScheduledEventSubscription(data, "USER_REMOVE")
-        payload.guild = guild
-        self.dispatch("raw_scheduled_event_user_remove", payload)
-
-        member = guild.get_member(data["user_id"])
-        if member is not None:
-            event = guild.get_scheduled_event(data["guild_scheduled_event_id"])
-            if event:
-                event.subscriber_count += 1
-                guild._add_scheduled_event(event)
-                self.dispatch("scheduled_event_user_remove", event, member)
-
-    def parse_guild_integrations_update(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is not None:
-            self.dispatch("guild_integrations_update", guild)
-        else:
-            _log.debug(
-                ("GUILD_INTEGRATIONS_UPDATE referencing an unknown guild ID: %s. Discarding."),
-                data["guild_id"],
-            )
-
-    def parse_integration_create(self, data) -> None:
-        guild_id = int(data.pop("guild_id"))
-        guild = self._get_guild(guild_id)
-        if guild is not None:
-            cls, _ = _integration_factory(data["type"])
-            integration = cls(data=data, guild=guild)
-            self.dispatch("integration_create", integration)
-        else:
-            _log.debug(
-                "INTEGRATION_CREATE referencing an unknown guild ID: %s. Discarding.",
-                guild_id,
-            )
-
-    def parse_integration_update(self, data) -> None:
-        guild_id = int(data.pop("guild_id"))
-        guild = self._get_guild(guild_id)
-        if guild is not None:
-            cls, _ = _integration_factory(data["type"])
-            integration = cls(data=data, guild=guild)
-            self.dispatch("integration_update", integration)
-        else:
-            _log.debug(
-                "INTEGRATION_UPDATE referencing an unknown guild ID: %s. Discarding.",
-                guild_id,
-            )
-
-    def parse_integration_delete(self, data) -> None:
-        guild_id = int(data["guild_id"])
-        guild = self._get_guild(guild_id)
-        if guild is not None:
-            raw = RawIntegrationDeleteEvent(data)
-            self.dispatch("raw_integration_delete", raw)
-        else:
-            _log.debug(
-                "INTEGRATION_DELETE referencing an unknown guild ID: %s. Discarding.",
-                guild_id,
-            )
-
-    def parse_webhooks_update(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is None:
-            _log.debug(
-                "WEBHOOKS_UPDATE referencing an unknown guild ID: %s. Discarding",
-                data["guild_id"],
-            )
-            return
-
-        channel_id = data["channel_id"]
-        if channel_id is not None:
-            channel = guild.get_channel(int(channel_id))
-            if channel is not None:
-                self.dispatch("webhooks_update", channel)
-            else:
-                _log.debug(
-                    "WEBHOOKS_UPDATE referencing an unknown channel ID: %s. Discarding.",
-                    data["channel_id"],
-                )
-        else:
-            _log.debug(
-                "WEBHOOKS_UPDATE channel ID was null for guild: %s. Discarding.",
-                data["guild_id"],
-            )
-
-    def parse_stage_instance_create(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is not None:
-            stage_instance = StageInstance(guild=guild, state=self, data=data)
-            guild._stage_instances[stage_instance.id] = stage_instance
-            self.dispatch("stage_instance_create", stage_instance)
-        else:
-            _log.debug(
-                "STAGE_INSTANCE_CREATE referencing unknown guild ID: %s. Discarding.",
-                data["guild_id"],
-            )
-
-    def parse_stage_instance_update(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is not None:
-            stage_instance = guild._stage_instances.get(int(data["id"]))
-            if stage_instance is not None:
-                old_stage_instance = copy.copy(stage_instance)
-                stage_instance._update(data)
-                self.dispatch("stage_instance_update", old_stage_instance, stage_instance)
-            else:
-                _log.debug(
-                    ("STAGE_INSTANCE_UPDATE referencing unknown stage instance ID: %s. Discarding."),
-                    data["id"],
-                )
-        else:
-            _log.debug(
-                "STAGE_INSTANCE_UPDATE referencing unknown guild ID: %s. Discarding.",
-                data["guild_id"],
-            )
-
-    def parse_stage_instance_delete(self, data) -> None:
-        guild = self._get_guild(int(data["guild_id"]))
-        if guild is not None:
-            try:
-                stage_instance = guild._stage_instances.pop(int(data["id"]))
-            except KeyError:
-                pass
-            else:
-                self.dispatch("stage_instance_delete", stage_instance)
-        else:
-            _log.debug(
-                "STAGE_INSTANCE_DELETE referencing unknown guild ID: %s. Discarding.",
-                data["guild_id"],
-            )
-
-    def parse_voice_state_update(self, data) -> None:
-        guild = self._get_guild(get_as_snowflake(data, "guild_id"))
-        channel_id = get_as_snowflake(data, "channel_id")
-        flags = self.member_cache_flags
-        # self.user is *always* cached when this is called
-        self_id = self.user.id  # type: ignore
-        if guild is not None:
-            if int(data["user_id"]) == self_id:
-                voice = self._get_voice_client(guild.id)
-                if voice is not None:
-                    coro = voice.on_voice_state_update(data)
-                    asyncio.create_task(logging_coroutine(coro, info="Voice Protocol voice state update handler"))
-            member, before, after = guild._update_voice_state(data, channel_id)  # type: ignore
-            if member is not None:
-                if flags.voice:
-                    if channel_id is None and flags._voice_only and member.id != self_id:
-                        # Only remove from cache if we only have the voice flag enabled
-                        # Member doesn't meet the Snowflake protocol currently
-                        guild._remove_member(member)  # type: ignore
-                    elif channel_id is not None:
-                        guild._add_member(member)
-
-                self.dispatch("voice_state_update", member, before, after)
-            else:
-                _log.debug(
-                    ("VOICE_STATE_UPDATE referencing an unknown member ID: %s. Discarding."),
-                    data["user_id"],
-                )
-
-    def parse_voice_server_update(self, data) -> None:
-        try:
-            key_id = int(data["guild_id"])
-        except KeyError:
-            key_id = int(data["channel_id"])
-
-        vc = self._get_voice_client(key_id)
-        if vc is not None:
-            coro = vc.on_voice_server_update(data)
-            asyncio.create_task(logging_coroutine(coro, info="Voice Protocol voice server update handler"))
-
-    def parse_voice_channel_status_update(self, data) -> None:
-        raw = RawVoiceChannelStatusUpdateEvent(data)
-        self.dispatch("raw_voice_channel_status_update", raw)
-        guild = self._get_guild(int(data["guild_id"]))
-        channel_id = int(data["id"])
-        if guild is not None:
-            channel = guild.get_channel(channel_id)
-            if channel is not None:
-                old_status = channel.status
-                channel.status = data.get("status", None)
-                self.dispatch("voice_channel_status_update", channel, old_status, channel.status)
-            else:
-                _log.debug(
-                    "VOICE_CHANNEL_STATUS_UPDATE referencing an unknown channel ID: %s. Discarding.",
-                    channel_id,
-                )
-        else:
-            _log.debug(
-                "VOICE_CHANNEL_STATUS_UPDATE referencing unknown guild ID: %s. Discarding.",
-                data["guild_id"],
-            )
-
-    def parse_typing_start(self, data) -> None:
-        raw = RawTypingEvent(data)
-
-        member_data = data.get("member")
-        if member_data:
-            guild = self._get_guild(raw.guild_id)
-            if guild is not None:
-                raw.member = Member(data=member_data, guild=guild, state=self)
-            else:
-                raw.member = None
-        else:
-            raw.member = None
-        self.dispatch("raw_typing", raw)
-
-        channel, guild = self._get_guild_channel(data)
-        if channel is not None:
-            user = raw.member or self._get_typing_user(channel, raw.user_id)
-
-            if user is not None:
-                self.dispatch("typing", channel, user, raw.when)
-
-    def _get_typing_user(self, channel: MessageableChannel | None, user_id: int) -> User | Member | None:
-        if isinstance(channel, DMChannel):
-            return channel.recipient or self.get_user(user_id)
-
-        elif isinstance(channel, (Thread, TextChannel)) and channel.guild is not None:
-            return channel.guild.get_member(user_id)  # type: ignore
-
-        elif isinstance(channel, GroupChannel):
-            return utils.find(lambda x: x.id == user_id, channel.recipients)
-
-        return self.get_user(user_id)
-
     async def _get_reaction_user(self, channel: MessageableChannel, user_id: int) -> User | Member | None:
         if isinstance(channel, TextChannel):
             return await channel.guild.get_member(user_id)