From b1607fb1dd0d6576ab262a61fb887162e1c91065 Mon Sep 17 00:00:00 2001 From: HopeBaron Date: Fri, 24 Jun 2022 21:36:51 +0300 Subject: [PATCH 01/57] Automod models [broken] --- .../src/main/kotlin/entity/DiscordAutoMod.kt | 71 +++++++++++++++++++ 1 file changed, 71 insertions(+) create mode 100644 common/src/main/kotlin/entity/DiscordAutoMod.kt diff --git a/common/src/main/kotlin/entity/DiscordAutoMod.kt b/common/src/main/kotlin/entity/DiscordAutoMod.kt new file mode 100644 index 000000000000..85c294e25a0f --- /dev/null +++ b/common/src/main/kotlin/entity/DiscordAutoMod.kt @@ -0,0 +1,71 @@ +package dev.kord.common.entity + +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable + +@Serializable +public data class DiscordAutoModRule( + val id: Snowflake, + @SerialName("guild_id") + val guildId: Snowflake, + val name: String, + @SerialName("creator_id") + val creatorId: Snowflake, + @SerialName("event_type") + val eventType: AutoModRuleEventType, + @SerialName("trigger_type") + val triggerType: AutoModRuleTriggerType, + @SerialName("trigger_metadata") + val triggerMetadata: AutoModTriggerMetadata, + val enabled: Boolean, + @SerialName("exempt_roles") + val exemptRoles: List, + @SerialName("exempt_channels") + val exemptChannels: List + +) + +@Serializable +public sealed class AutoModRuleEventType(value: Int) { + public object Keyword: AutoModRuleEventType(1) + public object HarmfulLink: AutoModRuleEventType(2) + public object Spam: AutoModRuleEventType(3) + public object KeywordPreset: AutoModRuleEventType(4) + +} + +@Serializable +public sealed class AutoModRuleTriggerType(value: Int) { + public object MessageSend: AutoModRuleTriggerType(1) +} + +@Serializable +public data class AutoModTriggerMetadata( + public val keywordFilter: List, + public val presets: List +) + +@Serializable +public sealed class AutoModPresetType(value: Int) { + public object Profanity : AutoModPresetType(1) + public object SexualContent : AutoModPresetType(2) + public object Slurs: AutoModPresetType(3) +} + +public sealed class AutoModActionType(value: Int) { + public object BlockMessage: AutoModActionType(1) + public object SendAlertMessage: AutoModActionType(2) + public object Timeout: AutoModActionType(3) +} +@Serializable +public class AutoModAction( + public val type: AutoModActionType, + @SerialName("action_metadata") + public val actionMetadata: AutoModActionMetadata +) +@Serializable +public class AutoModActionMetadata( + public val channelId: Snowflake, + @SerialName("duration_seconds") + public val durationSeconds: Int +) \ No newline at end of file From 5ab959ed81104d3909b46bdd9619a9fa80515475 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 6 Jul 2022 02:08:59 +0200 Subject: [PATCH 02/57] Fix Auto Moderation models --- .../src/main/kotlin/entity/DiscordAutoMod.kt | 71 ------ .../kotlin/entity/DiscordAutoModeration.kt | 211 ++++++++++++++++++ 2 files changed, 211 insertions(+), 71 deletions(-) delete mode 100644 common/src/main/kotlin/entity/DiscordAutoMod.kt create mode 100644 common/src/main/kotlin/entity/DiscordAutoModeration.kt diff --git a/common/src/main/kotlin/entity/DiscordAutoMod.kt b/common/src/main/kotlin/entity/DiscordAutoMod.kt deleted file mode 100644 index 85c294e25a0f..000000000000 --- a/common/src/main/kotlin/entity/DiscordAutoMod.kt +++ /dev/null @@ -1,71 +0,0 @@ -package dev.kord.common.entity - -import kotlinx.serialization.SerialName -import kotlinx.serialization.Serializable - -@Serializable -public data class DiscordAutoModRule( - val id: Snowflake, - @SerialName("guild_id") - val guildId: Snowflake, - val name: String, - @SerialName("creator_id") - val creatorId: Snowflake, - @SerialName("event_type") - val eventType: AutoModRuleEventType, - @SerialName("trigger_type") - val triggerType: AutoModRuleTriggerType, - @SerialName("trigger_metadata") - val triggerMetadata: AutoModTriggerMetadata, - val enabled: Boolean, - @SerialName("exempt_roles") - val exemptRoles: List, - @SerialName("exempt_channels") - val exemptChannels: List - -) - -@Serializable -public sealed class AutoModRuleEventType(value: Int) { - public object Keyword: AutoModRuleEventType(1) - public object HarmfulLink: AutoModRuleEventType(2) - public object Spam: AutoModRuleEventType(3) - public object KeywordPreset: AutoModRuleEventType(4) - -} - -@Serializable -public sealed class AutoModRuleTriggerType(value: Int) { - public object MessageSend: AutoModRuleTriggerType(1) -} - -@Serializable -public data class AutoModTriggerMetadata( - public val keywordFilter: List, - public val presets: List -) - -@Serializable -public sealed class AutoModPresetType(value: Int) { - public object Profanity : AutoModPresetType(1) - public object SexualContent : AutoModPresetType(2) - public object Slurs: AutoModPresetType(3) -} - -public sealed class AutoModActionType(value: Int) { - public object BlockMessage: AutoModActionType(1) - public object SendAlertMessage: AutoModActionType(2) - public object Timeout: AutoModActionType(3) -} -@Serializable -public class AutoModAction( - public val type: AutoModActionType, - @SerialName("action_metadata") - public val actionMetadata: AutoModActionMetadata -) -@Serializable -public class AutoModActionMetadata( - public val channelId: Snowflake, - @SerialName("duration_seconds") - public val durationSeconds: Int -) \ No newline at end of file diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/DiscordAutoModeration.kt new file mode 100644 index 000000000000..bae1e721d5b6 --- /dev/null +++ b/common/src/main/kotlin/entity/DiscordAutoModeration.kt @@ -0,0 +1,211 @@ +package dev.kord.common.entity + +import dev.kord.common.entity.optional.Optional +import dev.kord.common.entity.optional.OptionalSnowflake +import dev.kord.common.serialization.DurationInSeconds +import kotlinx.serialization.KSerializer +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable +import kotlinx.serialization.descriptors.PrimitiveKind +import kotlinx.serialization.descriptors.PrimitiveSerialDescriptor +import kotlinx.serialization.encoding.Decoder +import kotlinx.serialization.encoding.Encoder + +@Serializable +public data class DiscordAutoModerationRule( + val id: Snowflake, + @SerialName("guild_id") + val guildId: Snowflake, + val name: String, + @SerialName("creator_id") + val creatorId: Snowflake, + @SerialName("event_type") + val eventType: AutoModerationRuleEventType, + @SerialName("trigger_type") + val triggerType: AutoModerationRuleTriggerType, + @SerialName("trigger_metadata") + val triggerMetadata: AutoModerationRuleTriggerMetadata, + val actions: List, + val enabled: Boolean, + @SerialName("exempt_roles") + val exemptRoles: List, + @SerialName("exempt_channels") + val exemptChannels: List, +) + +/** Characterizes the type of content which can trigger the rule. */ +@Serializable(with = AutoModerationRuleTriggerType.Serializer::class) +public sealed class AutoModerationRuleTriggerType(public val value: Int) { + + final override fun equals(other: Any?): Boolean = + this === other || (other is AutoModerationRuleTriggerType && this.value == other.value) + + final override fun hashCode(): Int = value + + + /** An unknown [AutoModerationRuleTriggerType]. */ + public class Unknown(value: Int) : AutoModerationRuleTriggerType(value) + + /** Check if content contains words from a user defined list of keywords. */ + public object Keyword : AutoModerationRuleTriggerType(1) + + /** Check if content contains any harmful links. */ + public object HarmfulLink : AutoModerationRuleTriggerType(2) + + /** Check if content represents generic spam. */ + public object Spam : AutoModerationRuleTriggerType(3) + + /** Check if content contains words from internal pre-defined wordsets. */ + public object KeywordPreset : AutoModerationRuleTriggerType(4) + + + internal object Serializer : KSerializer { + + override val descriptor = + PrimitiveSerialDescriptor("dev.kord.common.entity.AutoModerationRuleTriggerType", PrimitiveKind.INT) + + override fun serialize(encoder: Encoder, value: AutoModerationRuleTriggerType) = encoder.encodeInt(value.value) + + override fun deserialize(decoder: Decoder) = when (val value = decoder.decodeInt()) { + 1 -> Keyword + 2 -> HarmfulLink + 3 -> Spam + 4 -> KeywordPreset + else -> Unknown(value) + } + } +} + +@Serializable +public data class AutoModerationRuleTriggerMetadata( + @SerialName("keyword_filter") + val keywordFilter: Optional> = Optional.Missing(), // TODO is this really optional? + val presets: Optional> = Optional.Missing(), // TODO is this really optional? +) + +@Serializable(with = AutoModerationKeywordPresetType.Serializer::class) +public sealed class AutoModerationKeywordPresetType(public val value: Int) { + + final override fun equals(other: Any?): Boolean = + this === other || (other is AutoModerationKeywordPresetType && this.value == other.value) + + final override fun hashCode(): Int = value + + + /** An unknown [AutoModerationKeywordPresetType]. */ + public class Unknown(value: Int) : AutoModerationKeywordPresetType(value) + + /** Words that may be considered forms of swearing or cursing. */ + public object Profanity : AutoModerationKeywordPresetType(1) + + /** Words that refer to sexually explicit behavior or activity. */ + public object SexualContent : AutoModerationKeywordPresetType(2) + + /** Personal insults or words that may be considered hate speech. */ + public object Slurs : AutoModerationKeywordPresetType(3) + + + internal object Serializer : KSerializer { + + override val descriptor = + PrimitiveSerialDescriptor("dev.kord.common.entity.AutoModerationKeywordPresetType", PrimitiveKind.INT) + + override fun serialize(encoder: Encoder, value: AutoModerationKeywordPresetType) = + encoder.encodeInt(value.value) + + override fun deserialize(decoder: Decoder) = when (val value = decoder.decodeInt()) { + 1 -> Profanity + 2 -> SexualContent + 3 -> Slurs + else -> Unknown(value) + } + } +} + +/** Indicates in what event context a rule should be checked. */ +@Serializable(with = AutoModerationRuleEventType.Serializer::class) +public sealed class AutoModerationRuleEventType(public val value: Int) { + + final override fun equals(other: Any?): Boolean = + this === other || (other is AutoModerationRuleEventType && this.value == other.value) + + final override fun hashCode(): Int = value + + + /** An unknown [AutoModerationRuleEventType]. */ + public class Unknown(value: Int) : AutoModerationRuleEventType(value) + + /** When a member sends or edits a message in the guild. */ + public object MessageSend : AutoModerationRuleEventType(1) + + + internal object Serializer : KSerializer { + + override val descriptor = + PrimitiveSerialDescriptor("dev.kord.common.entity.AutoModerationRuleEventType", PrimitiveKind.INT) + + override fun serialize(encoder: Encoder, value: AutoModerationRuleEventType) = encoder.encodeInt(value.value) + + override fun deserialize(decoder: Decoder) = when (val value = decoder.decodeInt()) { + 1 -> MessageSend + else -> Unknown(value) + } + } +} + +@Serializable +public data class AutoModerationAction( + val type: AutoModerationActionType, + val metadata: Optional, +) + +@Serializable(with = AutoModerationActionType.Serializer::class) +public sealed class AutoModerationActionType(public val value: Int) { + + final override fun equals(other: Any?): Boolean = + this === other || (other is AutoModerationActionType && this.value == other.value) + + final override fun hashCode(): Int = value + + + /** An unknown [AutoModerationActionType]. */ + public class Unknown(value: Int) : AutoModerationActionType(value) + + /** Blocks the content of a message according to the rule. */ + public object BlockMessage : AutoModerationActionType(1) + + /** Logs user content to a specified channel. */ + public object SendAlertMessage : AutoModerationActionType(2) + + /** + * Timeout user for a specified duration. + * + * A [Timeout] action can only be setup for [Keyword][AutoModerationRuleTriggerType.Keyword] rules. + * [ModerateMembers][Permission.ModerateMembers] permission is required to use the [Timeout] action type. + */ + public object Timeout : AutoModerationActionType(3) + + + internal object Serializer : KSerializer { + + override val descriptor = + PrimitiveSerialDescriptor("dev.kord.common.entity.AutoModerationActionType", PrimitiveKind.INT) + + override fun serialize(encoder: Encoder, value: AutoModerationActionType) = encoder.encodeInt(value.value) + + override fun deserialize(decoder: Decoder) = when (val value = decoder.decodeInt()) { + 1 -> BlockMessage + 2 -> SendAlertMessage + 3 -> Timeout + else -> Unknown(value) + } + } +} + +@Serializable +public data class AutoModerationActionMetadata( + @SerialName("channel_id") + public val channelId: OptionalSnowflake = OptionalSnowflake.Missing, // TODO is this really optional? + @SerialName("duration_seconds") + public val durationSeconds: Optional = Optional.Missing(), // TODO is this really optional? +) From 85f6a0c91462ade4369613d59a2a1aea54c35d03 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 6 Jul 2022 02:14:40 +0200 Subject: [PATCH 03/57] Add "Discord" prefix to Auto Moderation models --- .../src/main/kotlin/entity/DiscordAutoModeration.kt | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/DiscordAutoModeration.kt index bae1e721d5b6..9a3b742bf917 100644 --- a/common/src/main/kotlin/entity/DiscordAutoModeration.kt +++ b/common/src/main/kotlin/entity/DiscordAutoModeration.kt @@ -24,8 +24,8 @@ public data class DiscordAutoModerationRule( @SerialName("trigger_type") val triggerType: AutoModerationRuleTriggerType, @SerialName("trigger_metadata") - val triggerMetadata: AutoModerationRuleTriggerMetadata, - val actions: List, + val triggerMetadata: DiscordAutoModerationRuleTriggerMetadata, + val actions: List, val enabled: Boolean, @SerialName("exempt_roles") val exemptRoles: List, @@ -77,7 +77,7 @@ public sealed class AutoModerationRuleTriggerType(public val value: Int) { } @Serializable -public data class AutoModerationRuleTriggerMetadata( +public data class DiscordAutoModerationRuleTriggerMetadata( @SerialName("keyword_filter") val keywordFilter: Optional> = Optional.Missing(), // TODO is this really optional? val presets: Optional> = Optional.Missing(), // TODO is this really optional? @@ -154,9 +154,9 @@ public sealed class AutoModerationRuleEventType(public val value: Int) { } @Serializable -public data class AutoModerationAction( +public data class DiscordAutoModerationAction( val type: AutoModerationActionType, - val metadata: Optional, + val metadata: Optional, ) @Serializable(with = AutoModerationActionType.Serializer::class) @@ -203,7 +203,7 @@ public sealed class AutoModerationActionType(public val value: Int) { } @Serializable -public data class AutoModerationActionMetadata( +public data class DiscordAutoModerationActionMetadata( @SerialName("channel_id") public val channelId: OptionalSnowflake = OptionalSnowflake.Missing, // TODO is this really optional? @SerialName("duration_seconds") From cdf5451150a30cafc67aaa3b331740eed445a7e2 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 6 Jul 2022 02:49:44 +0200 Subject: [PATCH 04/57] Add Auto Moderation routes --- .../kotlin/entity/DiscordAutoModeration.kt | 2 +- rest/src/main/kotlin/route/Route.kt | 38 +++++++++++++++++++ 2 files changed, 39 insertions(+), 1 deletion(-) diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/DiscordAutoModeration.kt index 9a3b742bf917..e1401c562931 100644 --- a/common/src/main/kotlin/entity/DiscordAutoModeration.kt +++ b/common/src/main/kotlin/entity/DiscordAutoModeration.kt @@ -181,7 +181,7 @@ public sealed class AutoModerationActionType(public val value: Int) { * Timeout user for a specified duration. * * A [Timeout] action can only be setup for [Keyword][AutoModerationRuleTriggerType.Keyword] rules. - * [ModerateMembers][Permission.ModerateMembers] permission is required to use the [Timeout] action type. + * The [ModerateMembers][Permission.ModerateMembers] permission is required to use the [Timeout] action type. */ public object Timeout : AutoModerationActionType(3) diff --git a/rest/src/main/kotlin/route/Route.kt b/rest/src/main/kotlin/route/Route.kt index 3124b3f7c52b..df0291091f0c 100644 --- a/rest/src/main/kotlin/route/Route.kt +++ b/rest/src/main/kotlin/route/Route.kt @@ -82,6 +82,7 @@ public sealed class Route( public object InteractionToken : Key("{interaction.token}", true) public object ScheduledEventId : Key("{event.id}", true) public object StickerId : Key("{sticker.id}") + public object AutoModerationRuleId : Key("{auto_moderation_rule.id}") protected constructor( @@ -120,6 +121,43 @@ public sealed class Route( Route(HttpMethod.Get, "/guilds/$GuildId/audit-logs", DiscordAuditLog.serializer()) + /* + * Auto Moderation: + * https://discord.com/developers/docs/resources/auto-moderation + */ + + public object AutoModerationRulesForGuildList : + Route>( + HttpMethod.Get, + "/guilds/$GuildId/auto-moderation/rules", + ListSerializer(DiscordAutoModerationRule.serializer()), + ) + + public object AutoModerationRuleGet : + Route( + HttpMethod.Get, + "/guilds/$GuildId/auto-moderation/rules/$AutoModerationRuleId", + DiscordAutoModerationRule.serializer(), + ) + + public object AutoModerationRuleCreate : + Route( + HttpMethod.Post, + "/guilds/$GuildId/auto-moderation/rules", + DiscordAutoModerationRule.serializer(), + ) + + public object AutoModerationRuleModify : + Route( + HttpMethod.Patch, + "/guilds/$GuildId/auto-moderation/rules/$AutoModerationRuleId", + DiscordAutoModerationRule.serializer(), + ) + + public object AutoModerationRuleDelete : + Route(HttpMethod.Delete, "/guilds/$GuildId/auto-moderation/rules/$AutoModerationRuleId", NoStrategy) + + /* * Channel: * https://discord.com/developers/docs/resources/channel From 674e623e7efe872fd555386f9098db16abb0eb45 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 6 Jul 2022 03:12:26 +0200 Subject: [PATCH 05/57] Add Auto Moderation requests --- .../json/request/AutoModerationRequests.kt | 39 +++++++++++++++++++ 1 file changed, 39 insertions(+) create mode 100644 rest/src/main/kotlin/json/request/AutoModerationRequests.kt diff --git a/rest/src/main/kotlin/json/request/AutoModerationRequests.kt b/rest/src/main/kotlin/json/request/AutoModerationRequests.kt new file mode 100644 index 000000000000..6b8a4b781a5e --- /dev/null +++ b/rest/src/main/kotlin/json/request/AutoModerationRequests.kt @@ -0,0 +1,39 @@ +package dev.kord.rest.json.request + +import dev.kord.common.entity.* +import dev.kord.common.entity.optional.Optional +import dev.kord.common.entity.optional.OptionalBoolean +import kotlinx.serialization.SerialName +import kotlinx.serialization.Serializable + +@Serializable +public data class AutoModerationRuleCreateRequest( + val name: String, + @SerialName("event_type") + val eventType: AutoModerationRuleEventType, + @SerialName("trigger_type") + val triggerType: AutoModerationRuleTriggerType, + @SerialName("trigger_metadata") + val triggerMetadata: Optional = Optional.Missing(), + val actions: List, + val enabled: OptionalBoolean = OptionalBoolean.Missing, + @SerialName("exempt_roles") + val exemptRoles: Optional> = Optional.Missing(), + @SerialName("exempt_channels") + val exemptChannels: Optional> = Optional.Missing(), +) + +@Serializable +public data class AutoModerationRuleModifyRequest( + val name: Optional = Optional.Missing(), + @SerialName("event_type") + val eventType: Optional = Optional.Missing(), + @SerialName("trigger_metadata") + val triggerMetadata: Optional = Optional.Missing(), + val actions: Optional> = Optional.Missing(), + val enabled: OptionalBoolean = OptionalBoolean.Missing, + @SerialName("exempt_roles") + val exemptRoles: Optional> = Optional.Missing(), + @SerialName("exempt_channels") + val exemptChannels: Optional> = Optional.Missing(), +) From 1b587a204373f8583e5444c3a7de92c1f98d1074 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 6 Jul 2022 23:27:18 +0200 Subject: [PATCH 06/57] Add AutoModerationService --- .../kotlin/service/AutoModerationService.kt | 55 +++++++++++++++++++ rest/src/main/kotlin/service/RestClient.kt | 17 ++++-- 2 files changed, 68 insertions(+), 4 deletions(-) create mode 100644 rest/src/main/kotlin/service/AutoModerationService.kt diff --git a/rest/src/main/kotlin/service/AutoModerationService.kt b/rest/src/main/kotlin/service/AutoModerationService.kt new file mode 100644 index 000000000000..fa478bf815d5 --- /dev/null +++ b/rest/src/main/kotlin/service/AutoModerationService.kt @@ -0,0 +1,55 @@ +package dev.kord.rest.service + +import dev.kord.common.entity.DiscordAutoModerationRule +import dev.kord.common.entity.Snowflake +import dev.kord.rest.json.request.AutoModerationRuleCreateRequest +import dev.kord.rest.json.request.AutoModerationRuleModifyRequest +import dev.kord.rest.request.RequestHandler +import dev.kord.rest.request.auditLogReason +import dev.kord.rest.route.Route + +public class AutoModerationService(requestHandler: RequestHandler) : RestService(requestHandler) { + + public suspend fun listAutoModerationRulesForGuild(guildId: Snowflake): List = + call(Route.AutoModerationRulesForGuildList) { + keys[Route.GuildId] = guildId + } + + public suspend fun getAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): DiscordAutoModerationRule = + call(Route.AutoModerationRuleGet) { + keys[Route.GuildId] = guildId + keys[Route.AutoModerationRuleId] = ruleId + } + + public suspend fun createAutoModerationRule( + guildId: Snowflake, + request: AutoModerationRuleCreateRequest, + reason: String? = null, + ): DiscordAutoModerationRule = call(Route.AutoModerationRuleCreate) { + keys[Route.GuildId] = guildId + body(AutoModerationRuleCreateRequest.serializer(), request) + auditLogReason(reason) + } + + public suspend fun modifyAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + request: AutoModerationRuleModifyRequest, + reason: String? = null, + ): DiscordAutoModerationRule = call(Route.AutoModerationRuleModify) { + keys[Route.GuildId] = guildId + keys[Route.AutoModerationRuleId] = ruleId + body(AutoModerationRuleModifyRequest.serializer(), request) + auditLogReason(reason) + } + + public suspend fun deleteAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + reason: String? = null, + ): Unit = call(Route.AutoModerationRuleDelete) { + keys[Route.GuildId] = guildId + keys[Route.AutoModerationRuleId] = ruleId + auditLogReason(reason) + } +} diff --git a/rest/src/main/kotlin/service/RestClient.kt b/rest/src/main/kotlin/service/RestClient.kt index 31735120d4f7..3316c54c6345 100644 --- a/rest/src/main/kotlin/service/RestClient.kt +++ b/rest/src/main/kotlin/service/RestClient.kt @@ -10,19 +10,28 @@ import kotlin.contracts.InvocationKind import kotlin.contracts.contract public class RestClient(requestHandler: RequestHandler) : RestService(requestHandler) { + + // order like in docs: + + // interactions + public val interaction: InteractionService = InteractionService(requestHandler) + + // resources public val auditLog: AuditLogService = AuditLogService(requestHandler) + public val autoModeration: AutoModerationService = AutoModerationService(requestHandler) public val channel: ChannelService = ChannelService(requestHandler) public val emoji: EmojiService = EmojiService(requestHandler) public val guild: GuildService = GuildService(requestHandler) + public val template: TemplateService = TemplateService(requestHandler) public val invite: InviteService = InviteService(requestHandler) + public val stageInstance: StageInstanceService = StageInstanceService(requestHandler) + public val sticker: StickerService = StickerService(requestHandler) public val user: UserService = UserService(requestHandler) public val voice: VoiceService = VoiceService(requestHandler) public val webhook: WebhookService = WebhookService(requestHandler) + + // topics public val application: ApplicationService = ApplicationService(requestHandler) - public val template: TemplateService = TemplateService(requestHandler) - public val interaction: InteractionService = InteractionService(requestHandler) - public val stageInstance: StageInstanceService = StageInstanceService(requestHandler) - public val sticker: StickerService = StickerService(requestHandler) /** * Sends a request to the given [route]. This function exposes a direct call to the Discord api and allows From 01ba30624e96f8eb935cf19e85a2028ab7c930dc Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 6 Jul 2022 23:40:50 +0200 Subject: [PATCH 07/57] Add Auto Moderation to Audit Log --- common/src/main/kotlin/entity/AuditLog.kt | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/common/src/main/kotlin/entity/AuditLog.kt b/common/src/main/kotlin/entity/AuditLog.kt index 71318721f7fd..83c755210705 100644 --- a/common/src/main/kotlin/entity/AuditLog.kt +++ b/common/src/main/kotlin/entity/AuditLog.kt @@ -27,6 +27,8 @@ public data class DiscordAuditLog( val users: List, @SerialName("audit_log_entries") val auditLogEntries: List, + @SerialName("auto_moderation_rules") + val autoModerationRules: List, val integrations: List, val threads: List ) @@ -486,6 +488,10 @@ public sealed class AuditLogEvent(public val value: Int) { public object ThreadUpdate : AuditLogEvent(111) public object ThreadDelete : AuditLogEvent(112) public object ApplicationCommandPermissionUpdate : AuditLogEvent(121) + public object AutoModerationRuleCreate : AuditLogEvent(140) + public object AutoModerationRuleUpdate : AuditLogEvent(141) + public object AutoModerationRuleDelete : AuditLogEvent(142) + public object AutoModerationBlockMessage : AuditLogEvent(143) internal object Serializer : KSerializer { @@ -545,6 +551,10 @@ public sealed class AuditLogEvent(public val value: Int) { 111 -> ThreadUpdate 112 -> ThreadDelete 121 -> ApplicationCommandPermissionUpdate + 140 -> AutoModerationRuleCreate + 141 -> AutoModerationRuleUpdate + 142 -> AutoModerationRuleDelete + 143 -> AutoModerationBlockMessage else -> Unknown(value) } } From 78da15b637d3cad6a496a8b2db04151eab87ad28 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 6 Jul 2022 23:55:52 +0200 Subject: [PATCH 08/57] Add `GuildFeature.AutoModeration` --- common/src/main/kotlin/entity/DiscordGuild.kt | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/common/src/main/kotlin/entity/DiscordGuild.kt b/common/src/main/kotlin/entity/DiscordGuild.kt index dec49a83fbab..dc7b3e90ec4f 100644 --- a/common/src/main/kotlin/entity/DiscordGuild.kt +++ b/common/src/main/kotlin/entity/DiscordGuild.kt @@ -183,13 +183,22 @@ public data class DiscordPartialGuild( @Serializable(with = GuildFeature.Serializer::class) public sealed class GuildFeature(public val value: String) { - override fun toString(): String = "GuildFeature(value=$value)" + final override fun equals(other: Any?): Boolean = + this === other || (other is GuildFeature && this.value == other.value) + final override fun hashCode(): Int = value.hashCode() + final override fun toString(): String = "GuildFeature(value=$value)" + + + /** An unknown [GuildFeature]. */ public class Unknown(value: String) : GuildFeature(value) /** Guild has access to set an animated guild banner image. */ public object AnimatedBanner : GuildFeature("ANIMATED_BANNER") + /** Guild has set up auto moderation rules. */ + public object AutoModeration : GuildFeature("AUTO_MODERATION") + /** Guild has access to set an invite splash background */ public object InviteSplash : GuildFeature("INVITE_SPLASH") @@ -258,12 +267,14 @@ public sealed class GuildFeature(public val value: String) { /** Guild is able to set role icons */ public object RoleIcons : GuildFeature("ROLE_ICONS") + internal object Serializer : KSerializer { override val descriptor: SerialDescriptor get() = PrimitiveSerialDescriptor("feature", PrimitiveKind.STRING) override fun deserialize(decoder: Decoder): GuildFeature = when (val value = decoder.decodeString()) { "ANIMATED_BANNER" -> AnimatedBanner + "AUTO_MODERATION" -> AutoModeration "INVITE_SPLASH" -> InviteSplash "VIP_REGIONS" -> VIPRegions "VANITY_URL" -> VanityUrl From 2f8b2cea2bafc5077f2f41f73cac2eb96600f575 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 6 Jul 2022 23:56:39 +0200 Subject: [PATCH 09/57] Add `MessageType.AutoModerationAction` --- common/src/main/kotlin/entity/DiscordMessage.kt | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/common/src/main/kotlin/entity/DiscordMessage.kt b/common/src/main/kotlin/entity/DiscordMessage.kt index 5194f5c945da..4916034ce4ac 100644 --- a/common/src/main/kotlin/entity/DiscordMessage.kt +++ b/common/src/main/kotlin/entity/DiscordMessage.kt @@ -774,10 +774,10 @@ public data class AllRemovedMessageReactions( @Serializable(with = MessageType.MessageTypeSerializer::class) public sealed class MessageType(public val code: Int) { - override fun equals(other: Any?): Boolean = + final override fun equals(other: Any?): Boolean = this === other || (other is MessageType && this.code == other.code) - override fun hashCode(): Int = code + final override fun hashCode(): Int = code /** The default code for unknown values. */ @@ -822,6 +822,8 @@ public sealed class MessageType(public val code: Int) { public object ThreadStarterMessage : MessageType(21) public object GuildInviteReminder : MessageType(22) public object ContextMenuCommand : MessageType(23) + public object AutoModerationAction : MessageType(24) + internal object MessageTypeSerializer : KSerializer { @@ -864,6 +866,7 @@ public sealed class MessageType(public val code: Int) { ThreadStarterMessage, GuildInviteReminder, ContextMenuCommand, + AutoModerationAction, ) } } From 52f933538684bff316e7875cddc73ae0f6415a73 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Thu, 7 Jul 2022 00:10:30 +0200 Subject: [PATCH 10/57] Add Auto Moderation Gateway Intents --- gateway/src/main/kotlin/Intent.kt | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/gateway/src/main/kotlin/Intent.kt b/gateway/src/main/kotlin/Intent.kt index d2c763310cf0..bd534d9d7db0 100644 --- a/gateway/src/main/kotlin/Intent.kt +++ b/gateway/src/main/kotlin/Intent.kt @@ -176,6 +176,20 @@ public sealed class Intent(public val code: DiscordBitSet) { */ public object GuildScheduledEvents : Intent(1 shl 16) + /** + * Enables the following events: + * - [AutoModerationRuleCreate] + * - [AutoModerationRuleUpdate] + * - [AutoModerationRuleDelete] + */ + public object AutoModerationConfiguration : Intent(1 shl 20) + + /** + * Enables the following events: + * - [AutoModerationActionExecution] + */ + public object AutoModerationExecution : Intent(1 shl 21) + public companion object { @OptIn(PrivilegedIntent::class) @@ -198,6 +212,8 @@ public sealed class Intent(public val code: DiscordBitSet) { DirectMessageTyping, MessageContent, GuildScheduledEvents, + AutoModerationConfiguration, + AutoModerationExecution, ) } } From c8169bf155cdf3e319cbd09a0577bb1df4089ec0 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Thu, 7 Jul 2022 00:52:17 +0200 Subject: [PATCH 11/57] Add Auto Moderation Gateway Events --- gateway/src/main/kotlin/Event.kt | 58 ++++++++++++++++++++++++++++++++ 1 file changed, 58 insertions(+) diff --git a/gateway/src/main/kotlin/Event.kt b/gateway/src/main/kotlin/Event.kt index 3dfac3f8f4f4..119ab37a0d75 100644 --- a/gateway/src/main/kotlin/Event.kt +++ b/gateway/src/main/kotlin/Event.kt @@ -128,6 +128,26 @@ public sealed class Event { descriptor, index, DiscordGuildApplicationCommandPermissions.serializer() ), sequence ) + "AUTO_MODERATION_RULE_CREATE" -> AutoModerationRuleCreate( + rule = decoder.decodeSerializableElement(descriptor, index, DiscordAutoModerationRule.serializer()), + sequence, + ) + "AUTO_MODERATION_RULE_UPDATE" -> AutoModerationRuleUpdate( + rule = decoder.decodeSerializableElement(descriptor, index, DiscordAutoModerationRule.serializer()), + sequence, + ) + "AUTO_MODERATION_RULE_DELETE" -> AutoModerationRuleDelete( + rule = decoder.decodeSerializableElement(descriptor, index, DiscordAutoModerationRule.serializer()), + sequence, + ) + "AUTO_MODERATION_ACTION_EXECUTION" -> AutoModerationActionExecution( + actionExecution = decoder.decodeSerializableElement( + descriptor, + index, + DiscordAutoModerationActionExecution.serializer(), + ), + sequence, + ) "CHANNEL_CREATE" -> ChannelCreate( decoder.decodeSerializableElement( descriptor, @@ -584,6 +604,44 @@ public data class ApplicationCommandPermissionsUpdate( override val sequence: Int? ) : DispatchEvent() +public data class AutoModerationRuleCreate(val rule: DiscordAutoModerationRule, override val sequence: Int?) : + DispatchEvent() + +public data class AutoModerationRuleUpdate(val rule: DiscordAutoModerationRule, override val sequence: Int?) : + DispatchEvent() + +public data class AutoModerationRuleDelete(val rule: DiscordAutoModerationRule, override val sequence: Int?) : + DispatchEvent() + +public data class AutoModerationActionExecution( + val actionExecution: DiscordAutoModerationActionExecution, + override val sequence: Int?, +) : DispatchEvent() + +@Serializable +public data class DiscordAutoModerationActionExecution( + @SerialName("guild_id") + val guildId: Snowflake, + val action: DiscordAutoModerationAction, + @SerialName("rule_id") + val ruleId: Snowflake, + @SerialName("rule_trigger_type") + val ruleTriggerType: AutoModerationRuleTriggerType, + @SerialName("user_id") + val userId: Snowflake, + @SerialName("channel_id") + val channelId: OptionalSnowflake = OptionalSnowflake.Missing, + @SerialName("message_id") + val messageId: OptionalSnowflake = OptionalSnowflake.Missing, + @SerialName("alert_system_message_id") + val alertSystemMessageId: OptionalSnowflake = OptionalSnowflake.Missing, + val content: String, + @SerialName("matched_keyword") + val matchedKeyword: String?, + @SerialName("matched_content") + val matchedContent: String?, +) + public data class ChannelCreate(val channel: DiscordChannel, override val sequence: Int?) : DispatchEvent() public data class ChannelUpdate(val channel: DiscordChannel, override val sequence: Int?) : DispatchEvent() public data class ChannelDelete(val channel: DiscordChannel, override val sequence: Int?) : DispatchEvent() From 4ff62967f72412301de4318b5f503a76e0061dfb Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Thu, 7 Jul 2022 00:54:07 +0200 Subject: [PATCH 12/57] Fix test --- rest/src/test/resources/json/auditlog.json | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/rest/src/test/resources/json/auditlog.json b/rest/src/test/resources/json/auditlog.json index ffb97baa9f12..891eda4a4ef5 100644 --- a/rest/src/test/resources/json/auditlog.json +++ b/rest/src/test/resources/json/auditlog.json @@ -120,5 +120,6 @@ } } ], + "auto_moderation_rules": [], "threads" : [] -} \ No newline at end of file +} From c51dbe2affaaa7bde3ef08f20539a61d3cbcd6d7 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Thu, 7 Jul 2022 06:25:38 +0200 Subject: [PATCH 13/57] Rename `AutoModerationKeywordPresetType` to `AutoModerationRuleKeywordPresetType` --- .../kotlin/entity/DiscordAutoModeration.kt | 24 +++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/DiscordAutoModeration.kt index e1401c562931..f6d32ff620cc 100644 --- a/common/src/main/kotlin/entity/DiscordAutoModeration.kt +++ b/common/src/main/kotlin/entity/DiscordAutoModeration.kt @@ -80,37 +80,37 @@ public sealed class AutoModerationRuleTriggerType(public val value: Int) { public data class DiscordAutoModerationRuleTriggerMetadata( @SerialName("keyword_filter") val keywordFilter: Optional> = Optional.Missing(), // TODO is this really optional? - val presets: Optional> = Optional.Missing(), // TODO is this really optional? + val presets: Optional> = Optional.Missing(), // TODO is this really optional? ) -@Serializable(with = AutoModerationKeywordPresetType.Serializer::class) -public sealed class AutoModerationKeywordPresetType(public val value: Int) { +@Serializable(with = AutoModerationRuleKeywordPresetType.Serializer::class) +public sealed class AutoModerationRuleKeywordPresetType(public val value: Int) { final override fun equals(other: Any?): Boolean = - this === other || (other is AutoModerationKeywordPresetType && this.value == other.value) + this === other || (other is AutoModerationRuleKeywordPresetType && this.value == other.value) final override fun hashCode(): Int = value - /** An unknown [AutoModerationKeywordPresetType]. */ - public class Unknown(value: Int) : AutoModerationKeywordPresetType(value) + /** An unknown [AutoModerationRuleKeywordPresetType]. */ + public class Unknown(value: Int) : AutoModerationRuleKeywordPresetType(value) /** Words that may be considered forms of swearing or cursing. */ - public object Profanity : AutoModerationKeywordPresetType(1) + public object Profanity : AutoModerationRuleKeywordPresetType(1) /** Words that refer to sexually explicit behavior or activity. */ - public object SexualContent : AutoModerationKeywordPresetType(2) + public object SexualContent : AutoModerationRuleKeywordPresetType(2) /** Personal insults or words that may be considered hate speech. */ - public object Slurs : AutoModerationKeywordPresetType(3) + public object Slurs : AutoModerationRuleKeywordPresetType(3) - internal object Serializer : KSerializer { + internal object Serializer : KSerializer { override val descriptor = - PrimitiveSerialDescriptor("dev.kord.common.entity.AutoModerationKeywordPresetType", PrimitiveKind.INT) + PrimitiveSerialDescriptor("dev.kord.common.entity.AutoModerationRuleKeywordPresetType", PrimitiveKind.INT) - override fun serialize(encoder: Encoder, value: AutoModerationKeywordPresetType) = + override fun serialize(encoder: Encoder, value: AutoModerationRuleKeywordPresetType) = encoder.encodeInt(value.value) override fun deserialize(decoder: Decoder) = when (val value = decoder.decodeInt()) { From 3485fba9c15d38d93177815e88af4ff7d13e52c1 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Thu, 7 Jul 2022 07:02:40 +0200 Subject: [PATCH 14/57] Remove TODOs, fields are indeed optional --- common/src/main/kotlin/entity/DiscordAutoModeration.kt | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/DiscordAutoModeration.kt index f6d32ff620cc..98c036477cfb 100644 --- a/common/src/main/kotlin/entity/DiscordAutoModeration.kt +++ b/common/src/main/kotlin/entity/DiscordAutoModeration.kt @@ -79,8 +79,8 @@ public sealed class AutoModerationRuleTriggerType(public val value: Int) { @Serializable public data class DiscordAutoModerationRuleTriggerMetadata( @SerialName("keyword_filter") - val keywordFilter: Optional> = Optional.Missing(), // TODO is this really optional? - val presets: Optional> = Optional.Missing(), // TODO is this really optional? + val keywordFilter: Optional> = Optional.Missing(), + val presets: Optional> = Optional.Missing(), ) @Serializable(with = AutoModerationRuleKeywordPresetType.Serializer::class) @@ -205,7 +205,7 @@ public sealed class AutoModerationActionType(public val value: Int) { @Serializable public data class DiscordAutoModerationActionMetadata( @SerialName("channel_id") - public val channelId: OptionalSnowflake = OptionalSnowflake.Missing, // TODO is this really optional? + public val channelId: OptionalSnowflake = OptionalSnowflake.Missing, @SerialName("duration_seconds") - public val durationSeconds: Optional = Optional.Missing(), // TODO is this really optional? + public val durationSeconds: Optional = Optional.Missing(), ) From 068c784f4e10a1a0b723e95247d576dadebcea7e Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Thu, 7 Jul 2022 07:15:38 +0200 Subject: [PATCH 15/57] Add missing `Optional` default --- common/src/main/kotlin/entity/DiscordAutoModeration.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/DiscordAutoModeration.kt index 98c036477cfb..bd6dfc57151e 100644 --- a/common/src/main/kotlin/entity/DiscordAutoModeration.kt +++ b/common/src/main/kotlin/entity/DiscordAutoModeration.kt @@ -156,7 +156,7 @@ public sealed class AutoModerationRuleEventType(public val value: Int) { @Serializable public data class DiscordAutoModerationAction( val type: AutoModerationActionType, - val metadata: Optional, + val metadata: Optional = Optional.Missing(), ) @Serializable(with = AutoModerationActionType.Serializer::class) From efcc54f50130e3860167cfa56f4493b421397217 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Fri, 8 Jul 2022 16:43:20 +0200 Subject: [PATCH 16/57] Add `DiscordAutoModerationRuleTriggerMetadata.allowList` --- common/src/main/kotlin/entity/DiscordAutoModeration.kt | 2 ++ 1 file changed, 2 insertions(+) diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/DiscordAutoModeration.kt index bd6dfc57151e..a28837ed1ea2 100644 --- a/common/src/main/kotlin/entity/DiscordAutoModeration.kt +++ b/common/src/main/kotlin/entity/DiscordAutoModeration.kt @@ -81,6 +81,8 @@ public data class DiscordAutoModerationRuleTriggerMetadata( @SerialName("keyword_filter") val keywordFilter: Optional> = Optional.Missing(), val presets: Optional> = Optional.Missing(), + @SerialName("allow_list") + val allowList: Optional> = Optional.Missing(), ) @Serializable(with = AutoModerationRuleKeywordPresetType.Serializer::class) From 4d03cf07bc9f0f54c6be3ceedbad0fe8db2916c7 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sat, 9 Jul 2022 03:48:13 +0200 Subject: [PATCH 17/57] Add builders --- .../AutoModerationActionBuilder.kt | 55 +++++++++ .../AutoModerationRuleBuilder.kt | 94 +++++++++++++++ .../AutoModerationRuleCreateBuilder.kt | 105 +++++++++++++++++ .../AutoModerationRuleModifyBuilder.kt | 111 ++++++++++++++++++ 4 files changed, 365 insertions(+) create mode 100644 rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt create mode 100644 rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleBuilder.kt create mode 100644 rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleCreateBuilder.kt create mode 100644 rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleModifyBuilder.kt diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt new file mode 100644 index 000000000000..af6c255949a8 --- /dev/null +++ b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt @@ -0,0 +1,55 @@ +package dev.kord.rest.builder.auto_moderation + +import dev.kord.common.annotation.KordDsl +import dev.kord.common.entity.AutoModerationActionType +import dev.kord.common.entity.AutoModerationActionType.* +import dev.kord.common.entity.DiscordAutoModerationAction +import dev.kord.common.entity.DiscordAutoModerationActionMetadata +import dev.kord.common.entity.Snowflake +import dev.kord.common.entity.optional.Optional +import dev.kord.common.entity.optional.optional +import dev.kord.common.entity.optional.optionalSnowflake +import dev.kord.rest.builder.RequestBuilder +import kotlin.time.Duration + +@KordDsl +public sealed class AutoModerationActionBuilder : RequestBuilder { + + public abstract val type: AutoModerationActionType + + protected open fun buildMetadata(): Optional = Optional.Missing() + + final override fun toRequest(): DiscordAutoModerationAction = DiscordAutoModerationAction( + type = type, + metadata = buildMetadata(), + ) +} + +@Suppress("CanSealedSubClassBeObject") // keep it as a class in case we want to add more in the future +@KordDsl +public class BlockMessageAutoModerationActionBuilder : AutoModerationActionBuilder() { + + override val type: BlockMessage get() = BlockMessage +} + +@KordDsl +public class SendAlertMessageAutoModerationActionBuilder( + public var channelId: Snowflake, +) : AutoModerationActionBuilder() { + + override val type: SendAlertMessage get() = SendAlertMessage + + override fun buildMetadata(): Optional.Value = + DiscordAutoModerationActionMetadata(channelId = channelId.optionalSnowflake()).optional() +} + +@KordDsl +public class TimeoutAutoModerationActionBuilder( + public var duration: Duration, +) : AutoModerationActionBuilder() { + + override val type: Timeout get() = Timeout + + override fun buildMetadata(): Optional.Value = + DiscordAutoModerationActionMetadata(durationSeconds = duration.optional()).optional() +} diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleBuilder.kt new file mode 100644 index 000000000000..c08f33e3d88e --- /dev/null +++ b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleBuilder.kt @@ -0,0 +1,94 @@ +package dev.kord.rest.builder.auto_moderation + +import dev.kord.common.annotation.KordDsl +import dev.kord.common.entity.AutoModerationRuleEventType +import dev.kord.common.entity.AutoModerationRuleKeywordPresetType +import dev.kord.common.entity.AutoModerationRuleTriggerType +import dev.kord.common.entity.AutoModerationRuleTriggerType.* +import dev.kord.common.entity.Snowflake +import kotlin.contracts.InvocationKind.EXACTLY_ONCE +import kotlin.contracts.contract +import kotlin.time.Duration + +@KordDsl +public sealed interface AutoModerationRuleBuilder { + public var reason: String? + public val name: String? + public fun assignName(name: String) + public val eventType: AutoModerationRuleEventType? + public fun assignEventType(eventType: AutoModerationRuleEventType) + public val triggerType: AutoModerationRuleTriggerType + public val actions: MutableList? + public fun assignActions(actions: MutableList) + public var enabled: Boolean? + public var exemptRoles: MutableList? + public fun exemptRole(roleId: Snowflake) { + exemptRoles?.add(roleId) ?: run { exemptRoles = mutableListOf(roleId) } + } + + public var exemptChannels: MutableList? + public fun exemptChannel(channelId: Snowflake) { + exemptChannels?.add(channelId) ?: run { exemptChannels = mutableListOf(channelId) } + } +} + +public inline fun AutoModerationRuleBuilder.blockMessage( + builder: BlockMessageAutoModerationActionBuilder.() -> Unit = {}, +) { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val action = BlockMessageAutoModerationActionBuilder().apply(builder) + actions?.add(action) ?: assignActions(mutableListOf(action)) +} + +public inline fun AutoModerationRuleBuilder.sendAlertMessage( + channelId: Snowflake, + builder: SendAlertMessageAutoModerationActionBuilder.() -> Unit = {}, +) { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val action = SendAlertMessageAutoModerationActionBuilder(channelId).apply(builder) + actions?.add(action) ?: assignActions(mutableListOf(action)) +} + +@KordDsl +public sealed interface KeywordAutoModerationRuleBuilder : AutoModerationRuleBuilder { + override val triggerType: Keyword get() = Keyword + public val keywords: MutableList? + public fun assignKeywords(keywords: MutableList) + public fun keyword(keyword: String) { + keywords?.add(keyword) ?: assignKeywords(mutableListOf(keyword)) + } +} + +public inline fun KeywordAutoModerationRuleBuilder.timeout( + duration: Duration, + builder: TimeoutAutoModerationActionBuilder.() -> Unit = {}, +) { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val action = TimeoutAutoModerationActionBuilder(duration).apply(builder) + actions?.add(action) ?: assignActions(mutableListOf(action)) +} + +@KordDsl +public sealed interface HarmfulLinkAutoModerationRuleBuilder : AutoModerationRuleBuilder { + override val triggerType: HarmfulLink get() = HarmfulLink +} + +@KordDsl +public sealed interface SpamAutoModerationRuleBuilder : AutoModerationRuleBuilder { + override val triggerType: Spam get() = Spam +} + +@KordDsl +public sealed interface KeywordPresetAutoModerationRuleBuilder : AutoModerationRuleBuilder { + override val triggerType: KeywordPreset get() = KeywordPreset + public val presets: MutableList? + public fun assignPresets(presets: MutableList) + public fun preset(preset: AutoModerationRuleKeywordPresetType) { + presets?.add(preset) ?: assignPresets(mutableListOf(preset)) + } + + public var allowList: MutableList? + public fun allow(substring: String) { + allowList?.add(substring) ?: run { allowList = mutableListOf(substring) } + } +} diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleCreateBuilder.kt new file mode 100644 index 000000000000..37a66c7bad79 --- /dev/null +++ b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleCreateBuilder.kt @@ -0,0 +1,105 @@ +package dev.kord.rest.builder.auto_moderation + +import dev.kord.common.annotation.KordDsl +import dev.kord.common.entity.AutoModerationRuleEventType +import dev.kord.common.entity.AutoModerationRuleKeywordPresetType +import dev.kord.common.entity.DiscordAutoModerationRuleTriggerMetadata +import dev.kord.common.entity.Snowflake +import dev.kord.common.entity.optional.Optional +import dev.kord.common.entity.optional.OptionalBoolean +import dev.kord.common.entity.optional.delegate.delegate +import dev.kord.common.entity.optional.map +import dev.kord.common.entity.optional.optional +import dev.kord.rest.builder.AuditRequestBuilder +import dev.kord.rest.json.request.AutoModerationRuleCreateRequest + +@KordDsl +public sealed class AutoModerationRuleCreateBuilder( + final override var name: String, + final override var eventType: AutoModerationRuleEventType, +) : AutoModerationRuleBuilder, AuditRequestBuilder { + final override var reason: String? = null + + final override fun assignName(name: String) { + this.name = name + } + + final override fun assignEventType(eventType: AutoModerationRuleEventType) { + this.eventType = eventType + } + + protected open fun buildTriggerMetadata(): Optional = Optional.Missing() + + final override var actions: MutableList = mutableListOf() + final override fun assignActions(actions: MutableList) { + this.actions = actions + } + + private var _enabled: OptionalBoolean = OptionalBoolean.Missing + final override var enabled: Boolean? by ::_enabled.delegate() + + private var _exemptRoles: Optional> = Optional.Missing() + final override var exemptRoles: MutableList? by ::_exemptRoles.delegate() + + private var _exemptChannels: Optional> = Optional.Missing() + final override var exemptChannels: MutableList? by ::_exemptChannels.delegate() + + final override fun toRequest(): AutoModerationRuleCreateRequest = AutoModerationRuleCreateRequest( + name = name, + eventType = eventType, + triggerType = triggerType, + triggerMetadata = buildTriggerMetadata(), + actions = actions.map { it.toRequest() }, + enabled = _enabled, + exemptRoles = _exemptRoles.map { it.toList() }, + exemptChannels = _exemptChannels.map { it.toList() }, + ) +} + +@KordDsl +public class KeywordAutoModerationRuleCreateBuilder( + name: String, + eventType: AutoModerationRuleEventType, +) : AutoModerationRuleCreateBuilder(name, eventType), KeywordAutoModerationRuleBuilder { + + override var keywords: MutableList = mutableListOf() + override fun assignKeywords(keywords: MutableList) { + this.keywords = keywords + } + + override fun buildTriggerMetadata(): Optional.Value = + DiscordAutoModerationRuleTriggerMetadata(keywordFilter = keywords.toList().optional()).optional() +} + +@KordDsl +public class HarmfulLinkAutoModerationRuleCreateBuilder( + name: String, + eventType: AutoModerationRuleEventType, +) : AutoModerationRuleCreateBuilder(name, eventType), HarmfulLinkAutoModerationRuleBuilder + +@KordDsl +public class SpamAutoModerationRuleCreateBuilder( + name: String, + eventType: AutoModerationRuleEventType, +) : AutoModerationRuleCreateBuilder(name, eventType), SpamAutoModerationRuleBuilder + +@KordDsl +public class KeywordPresetAutoModerationRuleCreateBuilder( + name: String, + eventType: AutoModerationRuleEventType, +) : AutoModerationRuleCreateBuilder(name, eventType), KeywordPresetAutoModerationRuleBuilder { + + override var presets: MutableList = mutableListOf() + override fun assignPresets(presets: MutableList) { + this.presets = presets + } + + private var _allowList: Optional> = Optional.Missing() + override var allowList: MutableList? by ::_allowList.delegate() + + override fun buildTriggerMetadata(): Optional.Value = + DiscordAutoModerationRuleTriggerMetadata( + presets = presets.toList().optional(), + allowList = _allowList.map { it.toList() }, + ).optional() +} diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleModifyBuilder.kt new file mode 100644 index 000000000000..8943287dd459 --- /dev/null +++ b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleModifyBuilder.kt @@ -0,0 +1,111 @@ +package dev.kord.rest.builder.auto_moderation + +import dev.kord.common.annotation.KordDsl +import dev.kord.common.entity.AutoModerationRuleEventType +import dev.kord.common.entity.AutoModerationRuleKeywordPresetType +import dev.kord.common.entity.DiscordAutoModerationRuleTriggerMetadata +import dev.kord.common.entity.Snowflake +import dev.kord.common.entity.optional.* +import dev.kord.common.entity.optional.delegate.delegate +import dev.kord.rest.builder.AuditRequestBuilder +import dev.kord.rest.json.request.AutoModerationRuleModifyRequest + +@KordDsl +public sealed class AutoModerationRuleModifyBuilder : + AutoModerationRuleBuilder, + AuditRequestBuilder { + final override var reason: String? = null + + private var _name: Optional = Optional.Missing() + final override var name: String? by ::_name.delegate() + final override fun assignName(name: String) { + this.name = name + } + + private var _eventType: Optional = Optional.Missing() + final override var eventType: AutoModerationRuleEventType? by ::_eventType.delegate() + final override fun assignEventType(eventType: AutoModerationRuleEventType) { + this.eventType = eventType + } + + protected open fun buildTriggerMetadata(): Optional = Optional.Missing() + + private var _actions: Optional> = Optional.Missing() + final override var actions: MutableList? by ::_actions.delegate() + final override fun assignActions(actions: MutableList) { + this.actions = actions + } + + private var _enabled: OptionalBoolean = OptionalBoolean.Missing + final override var enabled: Boolean? by ::_enabled.delegate() + + private var _exemptRoles: Optional> = Optional.Missing() + final override var exemptRoles: MutableList? by ::_exemptRoles.delegate() + + private var _exemptChannels: Optional> = Optional.Missing() + final override var exemptChannels: MutableList? by ::_exemptChannels.delegate() + + final override fun toRequest(): AutoModerationRuleModifyRequest = AutoModerationRuleModifyRequest( + name = _name, + eventType = _eventType, + triggerMetadata = buildTriggerMetadata(), + actions = _actions.mapList { it.toRequest() }, + enabled = _enabled, + exemptRoles = _exemptRoles.map { it.toList() }, + exemptChannels = _exemptChannels.map { it.toList() }, + ) +} + +@KordDsl +public class KeywordAutoModerationRuleModifyBuilder : + AutoModerationRuleModifyBuilder(), + KeywordAutoModerationRuleBuilder { + + private var _keywords: Optional> = Optional.Missing() + override var keywords: MutableList? by ::_keywords.delegate() + override fun assignKeywords(keywords: MutableList) { + this.keywords = keywords + } + + override fun buildTriggerMetadata(): Optional = + _keywords.map { DiscordAutoModerationRuleTriggerMetadata(keywordFilter = it.toList().optional()) } +} + +@Suppress("CanSealedSubClassBeObject") // has state in super class +@KordDsl +public class HarmfulLinkAutoModerationRuleModifyBuilder : + AutoModerationRuleModifyBuilder(), + HarmfulLinkAutoModerationRuleBuilder + +@Suppress("CanSealedSubClassBeObject") // has state in super class +@KordDsl +public class SpamAutoModerationRuleModifyBuilder : + AutoModerationRuleModifyBuilder(), + SpamAutoModerationRuleBuilder + +@KordDsl +public class KeywordPresetAutoModerationRuleModifyBuilder : + AutoModerationRuleModifyBuilder(), + KeywordPresetAutoModerationRuleBuilder { + + private var _presets: Optional> = Optional.Missing() + override var presets: MutableList? by ::_presets.delegate() + override fun assignPresets(presets: MutableList) { + this.presets = presets + } + + private var _allowList: Optional> = Optional.Missing() + override var allowList: MutableList? by ::_allowList.delegate() + + override fun buildTriggerMetadata(): Optional { + val presets = _presets + val allowList = _allowList + return when { + presets !is Optional.Missing || allowList !is Optional.Missing -> DiscordAutoModerationRuleTriggerMetadata( + presets = presets.map { it.toList() }, + allowList = allowList.map { it.toList() }, + ).optional() + else -> Optional.Missing() + } + } +} From 9591b4e941fdf500a9528587c846c4f90292c631 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 10 Jul 2022 00:45:11 +0200 Subject: [PATCH 18/57] Add docs for builders --- .../kotlin/entity/DiscordAutoModeration.kt | 6 +- .../src/main/kotlin/builder/RequestBuilder.kt | 16 ++-- .../AutoModerationActionBuilder.kt | 4 +- .../AutoModerationRuleBuilder.kt | 86 ++++++++++++++++++- 4 files changed, 98 insertions(+), 14 deletions(-) diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/DiscordAutoModeration.kt index a28837ed1ea2..fa3a1e84feca 100644 --- a/common/src/main/kotlin/entity/DiscordAutoModeration.kt +++ b/common/src/main/kotlin/entity/DiscordAutoModeration.kt @@ -1,5 +1,7 @@ package dev.kord.common.entity +import dev.kord.common.entity.AutoModerationRuleTriggerType.Keyword +import dev.kord.common.entity.Permission.ModerateMembers import dev.kord.common.entity.optional.Optional import dev.kord.common.entity.optional.OptionalSnowflake import dev.kord.common.serialization.DurationInSeconds @@ -182,8 +184,8 @@ public sealed class AutoModerationActionType(public val value: Int) { /** * Timeout user for a specified duration. * - * A [Timeout] action can only be setup for [Keyword][AutoModerationRuleTriggerType.Keyword] rules. - * The [ModerateMembers][Permission.ModerateMembers] permission is required to use the [Timeout] action type. + * A [Timeout] action can only be setup for [Keyword] rules. The [ModerateMembers] permission is required to use the + * [Timeout] action type. */ public object Timeout : AutoModerationActionType(3) diff --git a/rest/src/main/kotlin/builder/RequestBuilder.kt b/rest/src/main/kotlin/builder/RequestBuilder.kt index 83ef37dbd8d9..af0c99968647 100644 --- a/rest/src/main/kotlin/builder/RequestBuilder.kt +++ b/rest/src/main/kotlin/builder/RequestBuilder.kt @@ -2,15 +2,17 @@ package dev.kord.rest.builder import dev.kord.common.annotation.KordDsl -@KordDsl -public interface RequestBuilder { - public fun toRequest(): T -} - -@KordDsl -public interface AuditRequestBuilder : RequestBuilder { +public interface AuditBuilder { /** * The reason for this request, this will be displayed in the audit log. */ public var reason: String? } + +@KordDsl +public interface RequestBuilder { + public fun toRequest(): T +} + +@KordDsl +public interface AuditRequestBuilder : AuditBuilder, RequestBuilder diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt index af6c255949a8..8a88b21c105e 100644 --- a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt +++ b/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt @@ -15,6 +15,7 @@ import kotlin.time.Duration @KordDsl public sealed class AutoModerationActionBuilder : RequestBuilder { + /** The type of action. */ public abstract val type: AutoModerationActionType protected open fun buildMetadata(): Optional = Optional.Missing() @@ -28,12 +29,12 @@ public sealed class AutoModerationActionBuilder : RequestBuilder? + + /** Use this to set [actions][AutoModerationRuleBuilder.actions] for [AutoModerationRuleBuilder]. */ public fun assignActions(actions: MutableList) + + /** Whether the rule is enabled (`false` by default). */ public var enabled: Boolean? + + /** The IDs of the roles that should not be affected by the rule. */ public var exemptRoles: MutableList? + + /** Exempt a [role][roleId] from being affected by the rule. */ public fun exemptRole(roleId: Snowflake) { exemptRoles?.add(roleId) ?: run { exemptRoles = mutableListOf(roleId) } } + /** The IDs of the channels that should not be affected by the rule. */ public var exemptChannels: MutableList? + + /** Exempt a [channel][channelId] from being affected by the rule. */ public fun exemptChannel(channelId: Snowflake) { exemptChannels?.add(channelId) ?: run { exemptChannels = mutableListOf(channelId) } } } +/** Add a [BlockMessage] action which will execute whenever the rule is triggered. */ public inline fun AutoModerationRuleBuilder.blockMessage( builder: BlockMessageAutoModerationActionBuilder.() -> Unit = {}, ) { @@ -40,6 +66,11 @@ public inline fun AutoModerationRuleBuilder.blockMessage( actions?.add(action) ?: assignActions(mutableListOf(action)) } +/** + * Add a [SendAlertMessage] action which will execute whenever the rule is triggered. + * + * @param channelId the ID of the channel to which user content should be logged. + */ public inline fun AutoModerationRuleBuilder.sendAlertMessage( channelId: Snowflake, builder: SendAlertMessageAutoModerationActionBuilder.() -> Unit = {}, @@ -51,14 +82,40 @@ public inline fun AutoModerationRuleBuilder.sendAlertMessage( @KordDsl public sealed interface KeywordAutoModerationRuleBuilder : AutoModerationRuleBuilder { + override val triggerType: Keyword get() = Keyword + + /** + * Substrings which will be searched for in content. + * + * A keyword can be a phrase which contains multiple words. Wildcard symbols can be used to customize how each + * keyword will be matched. See + * [keyword matching strategies](https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object-keyword-matching-strategies). + */ public val keywords: MutableList? + + /** Use this to set [keywords][KeywordAutoModerationRuleBuilder.keywords] for [KeywordAutoModerationRuleBuilder]. */ public fun assignKeywords(keywords: MutableList) + + /** + * Add a [keyword] to [keywords]. + * + * A keyword can be a phrase which contains multiple words. Wildcard symbols can be used to customize how each + * keyword will be matched. See + * [keyword matching strategies](https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object-keyword-matching-strategies). + */ public fun keyword(keyword: String) { keywords?.add(keyword) ?: assignKeywords(mutableListOf(keyword)) } } +/** + * Add a [Timeout] action which will execute whenever the rule is triggered. + * + * The [ModerateMembers] permission is required to use this action. + * + * @param duration the timeout duration. + */ public inline fun KeywordAutoModerationRuleBuilder.timeout( duration: Duration, builder: TimeoutAutoModerationActionBuilder.() -> Unit = {}, @@ -80,15 +137,36 @@ public sealed interface SpamAutoModerationRuleBuilder : AutoModerationRuleBuilde @KordDsl public sealed interface KeywordPresetAutoModerationRuleBuilder : AutoModerationRuleBuilder { + override val triggerType: KeywordPreset get() = KeywordPreset + + /** The internally pre-defined wordsets which will be searched for in content. */ public val presets: MutableList? + + /** + * Use this to set [presets][KeywordPresetAutoModerationRuleBuilder.presets] for + * [KeywordPresetAutoModerationRuleBuilder]. + */ public fun assignPresets(presets: MutableList) + + /** Add a [preset] to [presets]. */ public fun preset(preset: AutoModerationRuleKeywordPresetType) { presets?.add(preset) ?: assignPresets(mutableListOf(preset)) } + /** + * Substrings which will be exempt from triggering the [presets]. + * + * A keyword can be a phrase which contains multiple words. + */ public var allowList: MutableList? - public fun allow(substring: String) { - allowList?.add(substring) ?: run { allowList = mutableListOf(substring) } + + /** + * Add a [keyword] to [allowList]. + * + * A keyword can be a phrase which contains multiple words. + */ + public fun allow(keyword: String) { + allowList?.add(keyword) ?: run { allowList = mutableListOf(keyword) } } } From 27444164f6a33159ae9fb72ab11705fdbbd680e9 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 10 Jul 2022 01:19:53 +0200 Subject: [PATCH 19/57] Add builder-taking functions to AutoModerationService --- .../src/main/kotlin/builder/RequestBuilder.kt | 1 + .../main/kotlin/service/AuditLogService.kt | 3 + .../kotlin/service/AutoModerationService.kt | 88 +++++++++++++++++++ 3 files changed, 92 insertions(+) diff --git a/rest/src/main/kotlin/builder/RequestBuilder.kt b/rest/src/main/kotlin/builder/RequestBuilder.kt index af0c99968647..ef24788825c5 100644 --- a/rest/src/main/kotlin/builder/RequestBuilder.kt +++ b/rest/src/main/kotlin/builder/RequestBuilder.kt @@ -2,6 +2,7 @@ package dev.kord.rest.builder import dev.kord.common.annotation.KordDsl +@KordDsl public interface AuditBuilder { /** * The reason for this request, this will be displayed in the audit log. diff --git a/rest/src/main/kotlin/service/AuditLogService.kt b/rest/src/main/kotlin/service/AuditLogService.kt index 3973b77a3219..ba9a24db33e9 100644 --- a/rest/src/main/kotlin/service/AuditLogService.kt +++ b/rest/src/main/kotlin/service/AuditLogService.kt @@ -6,6 +6,8 @@ import dev.kord.rest.builder.auditlog.AuditLogGetRequestBuilder import dev.kord.rest.json.request.AuditLogGetRequest import dev.kord.rest.request.RequestHandler import dev.kord.rest.route.Route +import kotlin.contracts.InvocationKind.EXACTLY_ONCE +import kotlin.contracts.contract public class AuditLogService(requestHandler: RequestHandler) : RestService(requestHandler) { @@ -13,6 +15,7 @@ public class AuditLogService(requestHandler: RequestHandler) : RestService(reque guildId: Snowflake, builder: AuditLogGetRequestBuilder.() -> Unit, ): DiscordAuditLog { + contract { callsInPlace(builder, EXACTLY_ONCE) } val request = AuditLogGetRequestBuilder().apply(builder).toRequest() return getAuditLogs(guildId, request) } diff --git a/rest/src/main/kotlin/service/AutoModerationService.kt b/rest/src/main/kotlin/service/AutoModerationService.kt index fa478bf815d5..713759ec8b0c 100644 --- a/rest/src/main/kotlin/service/AutoModerationService.kt +++ b/rest/src/main/kotlin/service/AutoModerationService.kt @@ -1,12 +1,16 @@ package dev.kord.rest.service +import dev.kord.common.entity.AutoModerationRuleEventType import dev.kord.common.entity.DiscordAutoModerationRule import dev.kord.common.entity.Snowflake +import dev.kord.rest.builder.auto_moderation.* import dev.kord.rest.json.request.AutoModerationRuleCreateRequest import dev.kord.rest.json.request.AutoModerationRuleModifyRequest import dev.kord.rest.request.RequestHandler import dev.kord.rest.request.auditLogReason import dev.kord.rest.route.Route +import kotlin.contracts.InvocationKind.EXACTLY_ONCE +import kotlin.contracts.contract public class AutoModerationService(requestHandler: RequestHandler) : RestService(requestHandler) { @@ -31,6 +35,50 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService auditLogReason(reason) } + public suspend inline fun createKeywordAutoModerationRule( + guildId: Snowflake, + name: String, + eventType: AutoModerationRuleEventType, + builder: KeywordAutoModerationRuleCreateBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = KeywordAutoModerationRuleCreateBuilder(name, eventType).apply(builder) + return createAutoModerationRule(guildId, request.toRequest(), request.reason) + } + + public suspend inline fun createHarmfulLinkAutoModerationRule( + guildId: Snowflake, + name: String, + eventType: AutoModerationRuleEventType, + builder: HarmfulLinkAutoModerationRuleCreateBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = HarmfulLinkAutoModerationRuleCreateBuilder(name, eventType).apply(builder) + return createAutoModerationRule(guildId, request.toRequest(), request.reason) + } + + public suspend inline fun createSpamAutoModerationRule( + guildId: Snowflake, + name: String, + eventType: AutoModerationRuleEventType, + builder: SpamAutoModerationRuleCreateBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = SpamAutoModerationRuleCreateBuilder(name, eventType).apply(builder) + return createAutoModerationRule(guildId, request.toRequest(), request.reason) + } + + public suspend inline fun createKeywordPresetAutoModerationRule( + guildId: Snowflake, + name: String, + eventType: AutoModerationRuleEventType, + builder: KeywordPresetAutoModerationRuleCreateBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = KeywordPresetAutoModerationRuleCreateBuilder(name, eventType).apply(builder) + return createAutoModerationRule(guildId, request.toRequest(), request.reason) + } + public suspend fun modifyAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, @@ -43,6 +91,46 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService auditLogReason(reason) } + public suspend inline fun modifyKeywordAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + builder: KeywordAutoModerationRuleModifyBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = KeywordAutoModerationRuleModifyBuilder().apply(builder) + return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) + } + + public suspend inline fun modifyHarmfulLinkAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + builder: HarmfulLinkAutoModerationRuleModifyBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = HarmfulLinkAutoModerationRuleModifyBuilder().apply(builder) + return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) + } + + public suspend inline fun modifySpamAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + builder: SpamAutoModerationRuleModifyBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = SpamAutoModerationRuleModifyBuilder().apply(builder) + return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) + } + + public suspend inline fun modifyKeywordPresetAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + builder: KeywordPresetAutoModerationRuleModifyBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = KeywordPresetAutoModerationRuleModifyBuilder().apply(builder) + return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) + } + public suspend fun deleteAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, From f4e861c97ead016fc06bf8a20e2e7fab6d350279 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 11 Jul 2022 20:50:05 +0200 Subject: [PATCH 20/57] Add cache models --- ...ordAutoModeration.kt => AutoModeration.kt} | 0 .../main/kotlin/cache/data/AutoModeration.kt | 90 +++++++++++++++++++ 2 files changed, 90 insertions(+) rename common/src/main/kotlin/entity/{DiscordAutoModeration.kt => AutoModeration.kt} (100%) create mode 100644 core/src/main/kotlin/cache/data/AutoModeration.kt diff --git a/common/src/main/kotlin/entity/DiscordAutoModeration.kt b/common/src/main/kotlin/entity/AutoModeration.kt similarity index 100% rename from common/src/main/kotlin/entity/DiscordAutoModeration.kt rename to common/src/main/kotlin/entity/AutoModeration.kt diff --git a/core/src/main/kotlin/cache/data/AutoModeration.kt b/core/src/main/kotlin/cache/data/AutoModeration.kt new file mode 100644 index 000000000000..32fb3dd74cc7 --- /dev/null +++ b/core/src/main/kotlin/cache/data/AutoModeration.kt @@ -0,0 +1,90 @@ +package dev.kord.core.cache.data + +import dev.kord.common.entity.* +import dev.kord.common.entity.optional.Optional +import dev.kord.common.entity.optional.OptionalSnowflake +import dev.kord.common.entity.optional.map +import dev.kord.common.serialization.DurationInSeconds +import kotlinx.serialization.Serializable + +@Serializable +public data class AutoModerationRuleData( + val id: Snowflake, + val guildId: Snowflake, + val name: String, + val creatorId: Snowflake, + val eventType: AutoModerationRuleEventType, + val triggerType: AutoModerationRuleTriggerType, + val triggerMetadata: AutoModerationRuleTriggerMetadataData, + val actions: List, + val enabled: Boolean, + val exemptRoles: List, + val exemptChannels: List, +) { + public companion object { + public fun from(rule: DiscordAutoModerationRule): AutoModerationRuleData = with(rule) { + AutoModerationRuleData( + id = id, + guildId = guildId, + name = name, + creatorId = creatorId, + eventType = eventType, + triggerType = triggerType, + triggerMetadata = AutoModerationRuleTriggerMetadataData.from(triggerMetadata), + actions = actions.map { AutoModerationActionData.from(it) }, + enabled = enabled, + exemptRoles = exemptRoles, + exemptChannels = exemptChannels, + ) + } + } +} + +@Serializable +public data class AutoModerationRuleTriggerMetadataData( + val keywordFilter: Optional> = Optional.Missing(), + val presets: Optional> = Optional.Missing(), + val allowList: Optional> = Optional.Missing(), +) { + public companion object { + public fun from(metadata: DiscordAutoModerationRuleTriggerMetadata): AutoModerationRuleTriggerMetadataData = + with(metadata) { + AutoModerationRuleTriggerMetadataData( + keywordFilter = keywordFilter, + presets = presets, + allowList = allowList, + ) + } + } +} + +@Serializable +public data class AutoModerationActionData( + val type: AutoModerationActionType, + val metadata: Optional = Optional.Missing(), +) { + public companion object { + public fun from(action: DiscordAutoModerationAction): AutoModerationActionData = with(action) { + AutoModerationActionData( + type = type, + metadata = metadata.map { AutoModerationActionMetadataData.from(it) }, + ) + } + } +} + +@Serializable +public data class AutoModerationActionMetadataData( + public val channelId: OptionalSnowflake = OptionalSnowflake.Missing, + public val durationSeconds: Optional = Optional.Missing(), +) { + public companion object { + public fun from(metadata: DiscordAutoModerationActionMetadata): AutoModerationActionMetadataData = + with(metadata) { + AutoModerationActionMetadataData( + channelId = channelId, + durationSeconds = durationSeconds, + ) + } + } +} From 058f7ce91862e437ebaebb6adfcf246d878f8b04 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Tue, 12 Jul 2022 14:57:55 +0200 Subject: [PATCH 21/57] Rename package --- .../AutoModerationActionBuilder.kt | 2 +- .../AutoModerationRuleBuilder.kt | 2 +- .../AutoModerationRuleCreateBuilder.kt | 2 +- .../AutoModerationRuleModifyBuilder.kt | 2 +- rest/src/main/kotlin/service/AutoModerationService.kt | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) rename rest/src/main/kotlin/builder/{auto_moderation => automoderation}/AutoModerationActionBuilder.kt (97%) rename rest/src/main/kotlin/builder/{auto_moderation => automoderation}/AutoModerationRuleBuilder.kt (99%) rename rest/src/main/kotlin/builder/{auto_moderation => automoderation}/AutoModerationRuleCreateBuilder.kt (98%) rename rest/src/main/kotlin/builder/{auto_moderation => automoderation}/AutoModerationRuleModifyBuilder.kt (99%) diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt similarity index 97% rename from rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt rename to rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt index 8a88b21c105e..5db39fd739e2 100644 --- a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationActionBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt @@ -1,4 +1,4 @@ -package dev.kord.rest.builder.auto_moderation +package dev.kord.rest.builder.automoderation import dev.kord.common.annotation.KordDsl import dev.kord.common.entity.AutoModerationActionType diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt similarity index 99% rename from rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleBuilder.kt rename to rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index fb3095c4af68..f58df21be5c0 100644 --- a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -1,4 +1,4 @@ -package dev.kord.rest.builder.auto_moderation +package dev.kord.rest.builder.automoderation import dev.kord.common.annotation.KordDsl import dev.kord.common.entity.AutoModerationActionType.* diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt similarity index 98% rename from rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleCreateBuilder.kt rename to rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt index 37a66c7bad79..61060cf89cb1 100644 --- a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleCreateBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt @@ -1,4 +1,4 @@ -package dev.kord.rest.builder.auto_moderation +package dev.kord.rest.builder.automoderation import dev.kord.common.annotation.KordDsl import dev.kord.common.entity.AutoModerationRuleEventType diff --git a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt similarity index 99% rename from rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleModifyBuilder.kt rename to rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt index 8943287dd459..7046438b3b96 100644 --- a/rest/src/main/kotlin/builder/auto_moderation/AutoModerationRuleModifyBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt @@ -1,4 +1,4 @@ -package dev.kord.rest.builder.auto_moderation +package dev.kord.rest.builder.automoderation import dev.kord.common.annotation.KordDsl import dev.kord.common.entity.AutoModerationRuleEventType diff --git a/rest/src/main/kotlin/service/AutoModerationService.kt b/rest/src/main/kotlin/service/AutoModerationService.kt index 713759ec8b0c..817251873f4a 100644 --- a/rest/src/main/kotlin/service/AutoModerationService.kt +++ b/rest/src/main/kotlin/service/AutoModerationService.kt @@ -3,7 +3,7 @@ package dev.kord.rest.service import dev.kord.common.entity.AutoModerationRuleEventType import dev.kord.common.entity.DiscordAutoModerationRule import dev.kord.common.entity.Snowflake -import dev.kord.rest.builder.auto_moderation.* +import dev.kord.rest.builder.automoderation.* import dev.kord.rest.json.request.AutoModerationRuleCreateRequest import dev.kord.rest.json.request.AutoModerationRuleModifyRequest import dev.kord.rest.request.RequestHandler From 307cf3c1a0115d96c36ba079866fe9b95e6dc946 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Tue, 12 Jul 2022 18:18:37 +0200 Subject: [PATCH 22/57] Add `TypedAutoModerationRuleBuilder` and `UntypedAutoModerationRuleModifyBuilder` --- .../AutoModerationRuleBuilder.kt | 24 ++++++++++++++----- .../AutoModerationRuleCreateBuilder.kt | 2 +- .../AutoModerationRuleModifyBuilder.kt | 15 ++++++++---- .../kotlin/service/AutoModerationService.kt | 10 ++++++++ 4 files changed, 40 insertions(+), 11 deletions(-) diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index f58df21be5c0..fe275ea43180 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -28,8 +28,13 @@ public sealed interface AutoModerationRuleBuilder : AuditBuilder { /** Use this to set [eventType][AutoModerationRuleBuilder.eventType] for [AutoModerationRuleBuilder]. */ public fun assignEventType(eventType: AutoModerationRuleEventType) - /** The rule [trigger type][AutoModerationRuleTriggerType]. */ - public val triggerType: AutoModerationRuleTriggerType + /** + * The rule [trigger type][AutoModerationRuleTriggerType]. + * + * This might be `null`, if the function that created this builder doesn't know the trigger type based on the + * type system. + */ + public val triggerType: AutoModerationRuleTriggerType? /** The actions which will execute when the rule is triggered. */ public val actions: MutableList? @@ -81,7 +86,14 @@ public inline fun AutoModerationRuleBuilder.sendAlertMessage( } @KordDsl -public sealed interface KeywordAutoModerationRuleBuilder : AutoModerationRuleBuilder { +public sealed interface TypedAutoModerationRuleBuilder : AutoModerationRuleBuilder { + + /** The rule [trigger type][AutoModerationRuleTriggerType]. */ + override val triggerType: AutoModerationRuleTriggerType +} + +@KordDsl +public sealed interface KeywordAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { override val triggerType: Keyword get() = Keyword @@ -126,17 +138,17 @@ public inline fun KeywordAutoModerationRuleBuilder.timeout( } @KordDsl -public sealed interface HarmfulLinkAutoModerationRuleBuilder : AutoModerationRuleBuilder { +public sealed interface HarmfulLinkAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { override val triggerType: HarmfulLink get() = HarmfulLink } @KordDsl -public sealed interface SpamAutoModerationRuleBuilder : AutoModerationRuleBuilder { +public sealed interface SpamAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { override val triggerType: Spam get() = Spam } @KordDsl -public sealed interface KeywordPresetAutoModerationRuleBuilder : AutoModerationRuleBuilder { +public sealed interface KeywordPresetAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { override val triggerType: KeywordPreset get() = KeywordPreset diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt index 61060cf89cb1..16fb08dfab75 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt @@ -17,7 +17,7 @@ import dev.kord.rest.json.request.AutoModerationRuleCreateRequest public sealed class AutoModerationRuleCreateBuilder( final override var name: String, final override var eventType: AutoModerationRuleEventType, -) : AutoModerationRuleBuilder, AuditRequestBuilder { +) : TypedAutoModerationRuleBuilder, AuditRequestBuilder { final override var reason: String? = null final override fun assignName(name: String) { diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt index 7046438b3b96..b113e20fa7f4 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt @@ -1,10 +1,7 @@ package dev.kord.rest.builder.automoderation import dev.kord.common.annotation.KordDsl -import dev.kord.common.entity.AutoModerationRuleEventType -import dev.kord.common.entity.AutoModerationRuleKeywordPresetType -import dev.kord.common.entity.DiscordAutoModerationRuleTriggerMetadata -import dev.kord.common.entity.Snowflake +import dev.kord.common.entity.* import dev.kord.common.entity.optional.* import dev.kord.common.entity.optional.delegate.delegate import dev.kord.rest.builder.AuditRequestBuilder @@ -56,6 +53,16 @@ public sealed class AutoModerationRuleModifyBuilder : ) } +@KordDsl +public class UntypedAutoModerationRuleModifyBuilder : AutoModerationRuleModifyBuilder() { + + /** + * This is always `null`, the function that created this builder doesn't know the + * [trigger type][AutoModerationRuleTriggerType] based on the type system. + */ + override val triggerType: Nothing? get() = null +} + @KordDsl public class KeywordAutoModerationRuleModifyBuilder : AutoModerationRuleModifyBuilder(), diff --git a/rest/src/main/kotlin/service/AutoModerationService.kt b/rest/src/main/kotlin/service/AutoModerationService.kt index 817251873f4a..44e1b11bd5ac 100644 --- a/rest/src/main/kotlin/service/AutoModerationService.kt +++ b/rest/src/main/kotlin/service/AutoModerationService.kt @@ -91,6 +91,16 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService auditLogReason(reason) } + public suspend inline fun modifyUntypedAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + builder: UntypedAutoModerationRuleModifyBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = UntypedAutoModerationRuleModifyBuilder().apply(builder) + return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) + } + public suspend inline fun modifyKeywordAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, From 9509d100be9764b59ab59bde172c23531aef9473 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Tue, 12 Jul 2022 19:02:05 +0200 Subject: [PATCH 23/57] Start adding core models/functions --- .../src/main/kotlin/behavior/GuildBehavior.kt | 52 +++++++ .../AutoModerationRuleBehavior.kt | 108 +++++++++++++ .../automoderation/AutoModerationRule.kt | 146 ++++++++++++++++++ 3 files changed, 306 insertions(+) create mode 100644 core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt create mode 100644 core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt diff --git a/core/src/main/kotlin/behavior/GuildBehavior.kt b/core/src/main/kotlin/behavior/GuildBehavior.kt index 2b9143d60a26..1ba9de88f091 100644 --- a/core/src/main/kotlin/behavior/GuildBehavior.kt +++ b/core/src/main/kotlin/behavior/GuildBehavior.kt @@ -4,6 +4,7 @@ import dev.kord.cache.api.query import dev.kord.common.annotation.DeprecatedSinceKord import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.* +import dev.kord.common.entity.AutoModerationRuleEventType.MessageSend import dev.kord.common.entity.optional.Optional import dev.kord.common.entity.optional.unwrap import dev.kord.common.exception.RequestException @@ -16,6 +17,10 @@ import dev.kord.core.entity.application.GuildApplicationCommand import dev.kord.core.entity.application.GuildChatInputCommand import dev.kord.core.entity.application.GuildMessageCommand import dev.kord.core.entity.application.GuildUserCommand +import dev.kord.core.entity.automoderation.HarmfulLinkAutoModerationRule +import dev.kord.core.entity.automoderation.KeywordAutoModerationRule +import dev.kord.core.entity.automoderation.KeywordPresetAutoModerationRule +import dev.kord.core.entity.automoderation.SpamAutoModerationRule import dev.kord.core.entity.channel.* import dev.kord.core.entity.channel.thread.ThreadChannel import dev.kord.core.event.guild.MembersChunkEvent @@ -30,6 +35,10 @@ import dev.kord.gateway.start import dev.kord.rest.Image import dev.kord.rest.NamedFile import dev.kord.rest.builder.auditlog.AuditLogGetRequestBuilder +import dev.kord.rest.builder.automoderation.HarmfulLinkAutoModerationRuleCreateBuilder +import dev.kord.rest.builder.automoderation.KeywordAutoModerationRuleCreateBuilder +import dev.kord.rest.builder.automoderation.KeywordPresetAutoModerationRuleCreateBuilder +import dev.kord.rest.builder.automoderation.SpamAutoModerationRuleCreateBuilder import dev.kord.rest.builder.ban.BanCreateBuilder import dev.kord.rest.builder.channel.* import dev.kord.rest.builder.guild.* @@ -49,6 +58,7 @@ import kotlinx.coroutines.flow.* import kotlinx.datetime.Instant import java.util.* import kotlin.contracts.InvocationKind +import kotlin.contracts.InvocationKind.EXACTLY_ONCE import kotlin.contracts.contract /** @@ -1048,3 +1058,45 @@ public suspend fun GuildBehavior.createScheduledEvent( return GuildScheduledEvent(data, kord, supplier) } + +// TODO documentation + +public suspend inline fun GuildBehavior.createKeywordAutoModerationRule( + name: String, + eventType: AutoModerationRuleEventType = MessageSend, + builder: KeywordAutoModerationRuleCreateBuilder.() -> Unit, +): KeywordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.createKeywordAutoModerationRule(guildId = id, name, eventType, builder) + return KeywordAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} + +public suspend inline fun GuildBehavior.createHarmfulLinkAutoModerationRule( + name: String, + eventType: AutoModerationRuleEventType = MessageSend, + builder: HarmfulLinkAutoModerationRuleCreateBuilder.() -> Unit, +): HarmfulLinkAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.createHarmfulLinkAutoModerationRule(guildId = id, name, eventType, builder) + return HarmfulLinkAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} + +public suspend inline fun GuildBehavior.createSpamAutoModerationRule( + name: String, + eventType: AutoModerationRuleEventType = MessageSend, + builder: SpamAutoModerationRuleCreateBuilder.() -> Unit, +): SpamAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.createSpamAutoModerationRule(guildId = id, name, eventType, builder) + return SpamAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} + +public suspend inline fun GuildBehavior.createKeywordPresetAutoModerationRule( + name: String, + eventType: AutoModerationRuleEventType = MessageSend, + builder: KeywordPresetAutoModerationRuleCreateBuilder.() -> Unit, +): KeywordPresetAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.createKeywordPresetAutoModerationRule(guildId = id, name, eventType, builder) + return KeywordPresetAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt new file mode 100644 index 000000000000..4b2b97ad6178 --- /dev/null +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -0,0 +1,108 @@ +package dev.kord.core.behavior.automoderation + +import dev.kord.common.entity.AutoModerationRuleTriggerType +import dev.kord.common.entity.AutoModerationRuleTriggerType.* +import dev.kord.common.entity.Snowflake +import dev.kord.core.behavior.GuildBehavior +import dev.kord.core.cache.data.AutoModerationRuleData +import dev.kord.core.entity.Guild +import dev.kord.core.entity.KordEntity +import dev.kord.core.entity.Strategizable +import dev.kord.core.entity.automoderation.* +import dev.kord.core.entity.automoderation.AutoModerationRule +import dev.kord.core.supplier.EntitySupplyStrategy +import dev.kord.rest.builder.automoderation.* +import java.util.Objects +import kotlin.contracts.InvocationKind.EXACTLY_ONCE +import kotlin.contracts.contract + +// TODO documentation, missing vals/funs, factory methods, creation from unsafe + +public interface AutoModerationRuleBehavior : KordEntity, Strategizable { + + /** The ID of the [Guild] which this rule belongs to. */ + public val guildId: Snowflake + + /** The behavior of the [Guild] which this rule belongs to. */ + public val guild: GuildBehavior get() = GuildBehavior(guildId, kord) + + /** The rule [trigger type][AutoModerationRuleTriggerType]. */ + public val triggerType: AutoModerationRuleTriggerType? + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleBehavior +} + +internal infix fun AutoModerationRuleBehavior.autoModerationRuleIsEqualTo(other: Any?) = + this === other || (other is AutoModerationRuleBehavior && this.id == other.id && this.guildId == other.guildId) + +internal fun AutoModerationRuleBehavior.hashAutoModerationRule() = Objects.hash(id, guildId) + +public suspend inline fun AutoModerationRuleBehavior.edit( + builder: UntypedAutoModerationRuleModifyBuilder.() -> Unit, +): AutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.modifyUntypedAutoModerationRule(guildId, ruleId = id, builder) + return AutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} + + +public interface TypedAutoModerationRuleBehavior : AutoModerationRuleBehavior { + override val triggerType: AutoModerationRuleTriggerType + override fun withStrategy(strategy: EntitySupplyStrategy<*>): TypedAutoModerationRuleBehavior +} + + +public interface KeywordAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + override val triggerType: Keyword get() = Keyword + override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordAutoModerationRuleBehavior +} + +public suspend inline fun KeywordAutoModerationRuleBehavior.edit( + builder: KeywordAutoModerationRuleModifyBuilder.() -> Unit, +): KeywordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.modifyKeywordAutoModerationRule(guildId, ruleId = id, builder) + return KeywordAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} + + +public interface HarmfulLinkAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + override val triggerType: HarmfulLink get() = HarmfulLink + override fun withStrategy(strategy: EntitySupplyStrategy<*>): HarmfulLinkAutoModerationRuleBehavior +} + +public suspend inline fun HarmfulLinkAutoModerationRuleBehavior.edit( + builder: HarmfulLinkAutoModerationRuleModifyBuilder.() -> Unit, +): HarmfulLinkAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.modifyHarmfulLinkAutoModerationRule(guildId, ruleId = id, builder) + return HarmfulLinkAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} + + +public interface SpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + override val triggerType: Spam get() = Spam + override fun withStrategy(strategy: EntitySupplyStrategy<*>): SpamAutoModerationRuleBehavior +} + +public suspend inline fun SpamAutoModerationRuleBehavior.edit( + builder: SpamAutoModerationRuleModifyBuilder.() -> Unit, +): SpamAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.modifySpamAutoModerationRule(guildId, ruleId = id, builder) + return SpamAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} + + +public interface KeywordPresetAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + override val triggerType: KeywordPreset get() = KeywordPreset + override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordPresetAutoModerationRuleBehavior +} + +public suspend inline fun KeywordPresetAutoModerationRuleBehavior.edit( + builder: KeywordPresetAutoModerationRuleModifyBuilder.() -> Unit, +): KeywordPresetAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.modifyKeywordPresetAutoModerationRule(guildId, ruleId = id, builder) + return KeywordPresetAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt new file mode 100644 index 000000000000..5c2ee6e422b2 --- /dev/null +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -0,0 +1,146 @@ +package dev.kord.core.entity.automoderation + +import dev.kord.common.entity.AutoModerationRuleEventType +import dev.kord.common.entity.AutoModerationRuleKeywordPresetType +import dev.kord.common.entity.AutoModerationRuleTriggerType +import dev.kord.common.entity.AutoModerationRuleTriggerType.* +import dev.kord.common.entity.Snowflake +import dev.kord.common.entity.optional.orEmpty +import dev.kord.core.Kord +import dev.kord.core.behavior.MemberBehavior +import dev.kord.core.behavior.automoderation.* +import dev.kord.core.behavior.automoderation.autoModerationRuleIsEqualTo +import dev.kord.core.behavior.automoderation.hashAutoModerationRule +import dev.kord.core.cache.data.AutoModerationRuleData +import dev.kord.core.supplier.EntitySupplier +import dev.kord.core.supplier.EntitySupplyStrategy + +// TODO missing vals, AutoModerationAction + +public sealed class AutoModerationRule( + public val data: AutoModerationRuleData, + final override val kord: Kord, + final override val supplier: EntitySupplier, + expectedTriggerType: AutoModerationRuleTriggerType?, +) : TypedAutoModerationRuleBehavior { + + init { + expectedTriggerType?.let { + require(data.triggerType == it) { "Wrong trigger type, expected $it but got ${data.triggerType}" } + } + } + + final override val id: Snowflake get() = data.id + + final override val guildId: Snowflake get() = data.guildId + + /** The rule name. */ + public val name: String get() = data.name + + public val creatorId: Snowflake get() = data.creatorId + public val creator: MemberBehavior get() = MemberBehavior(guildId, id = creatorId, kord) + + public val eventType: AutoModerationRuleEventType get() = data.eventType + + public val actions: List get() = TODO() + + /** Whether the rule is enabled. */ + public val isEnabled: Boolean get() = data.enabled + + abstract override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRule + + final override fun equals(other: Any?): Boolean = this autoModerationRuleIsEqualTo other + final override fun hashCode(): Int = hashAutoModerationRule() +} + +@PublishedApi +internal fun AutoModerationRule( + data: AutoModerationRuleData, + kord: Kord, + supplier: EntitySupplier, +): AutoModerationRule = when (data.triggerType) { + Keyword -> KeywordAutoModerationRule(data, kord, supplier) + HarmfulLink -> HarmfulLinkAutoModerationRule(data, kord, supplier) + Spam -> SpamAutoModerationRule(data, kord, supplier) + KeywordPreset -> KeywordPresetAutoModerationRule(data, kord, supplier) + is Unknown -> UnknownAutoModerationRule(data, kord, supplier) +} + + +public class KeywordAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : + AutoModerationRule(data, kord, supplier, expectedTriggerType = Keyword), + KeywordAutoModerationRuleBehavior { + + /** + * Substrings which will be searched for in content. + * + * A keyword can be a phrase which contains multiple words. Wildcard symbols can be used to customize how each + * keyword will be matched. See + * [keyword matching strategies](https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object-keyword-matching-strategies). + */ + public val keywords: List get() = data.triggerMetadata.keywordFilter.orEmpty() + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordAutoModerationRule = + KeywordAutoModerationRule(data, kord, strategy.supply(kord)) + + override fun toString(): String = "KeywordAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" +} + + +public class HarmfulLinkAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : + AutoModerationRule(data, kord, supplier, expectedTriggerType = HarmfulLink), + HarmfulLinkAutoModerationRuleBehavior { + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): HarmfulLinkAutoModerationRule = + HarmfulLinkAutoModerationRule(data, kord, strategy.supply(kord)) + + override fun toString(): String = "HarmfulLinkAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" +} + + +public class SpamAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : + AutoModerationRule(data, kord, supplier, expectedTriggerType = Spam), + SpamAutoModerationRuleBehavior { + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): SpamAutoModerationRule = + SpamAutoModerationRule(data, kord, strategy.supply(kord)) + + override fun toString(): String = "SpamAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" +} + + +public class KeywordPresetAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : + AutoModerationRule(data, kord, supplier, expectedTriggerType = KeywordPreset), + KeywordPresetAutoModerationRuleBehavior { + + /** The internally pre-defined wordsets which will be searched for in content. */ + public val presets: List get() = data.triggerMetadata.presets.orEmpty() + + /** + * Substrings which will be exempt from triggering the [presets]. + * + * A keyword can be a phrase which contains multiple words. + */ + public val allowList: List get() = data.triggerMetadata.allowList.orEmpty() + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordPresetAutoModerationRule = + KeywordPresetAutoModerationRule(data, kord, strategy.supply(kord)) + + override fun toString(): String = "KeywordPresetAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" +} + + +public class UnknownAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : + AutoModerationRule(data, kord, supplier, expectedTriggerType = null) { + + init { + require(data.triggerType is Unknown) { "Expected unknown trigger type but got ${data.triggerType}" } + } + + override val triggerType: Unknown get() = data.triggerType as Unknown + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): UnknownAutoModerationRule = + UnknownAutoModerationRule(data, kord, strategy.supply(kord)) + + override fun toString(): String = "UnknownAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" +} From b056320fe29eac22d89337d1eb523fe9c7a20039 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 17 Jul 2022 19:04:26 +0200 Subject: [PATCH 24/57] Add missing properties to `AutoModerationRule` --- .../AutoModerationRuleBehavior.kt | 2 +- .../automoderation/AutoModerationRule.kt | 41 ++++++++++++++----- 2 files changed, 31 insertions(+), 12 deletions(-) diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index 4b2b97ad6178..2ad25ef6e505 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -20,7 +20,7 @@ import kotlin.contracts.contract public interface AutoModerationRuleBehavior : KordEntity, Strategizable { - /** The ID of the [Guild] which this rule belongs to. */ + /** The ID of the [Guild] which this rule belongs to. */ public val guildId: Snowflake /** The behavior of the [Guild] which this rule belongs to. */ diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 5c2ee6e422b2..8357a9c553ac 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -8,15 +8,16 @@ import dev.kord.common.entity.Snowflake import dev.kord.common.entity.optional.orEmpty import dev.kord.core.Kord import dev.kord.core.behavior.MemberBehavior +import dev.kord.core.behavior.RoleBehavior import dev.kord.core.behavior.automoderation.* -import dev.kord.core.behavior.automoderation.autoModerationRuleIsEqualTo -import dev.kord.core.behavior.automoderation.hashAutoModerationRule +import dev.kord.core.behavior.channel.GuildChannelBehavior import dev.kord.core.cache.data.AutoModerationRuleData +import dev.kord.core.entity.Member +import dev.kord.core.entity.Role +import dev.kord.core.entity.channel.GuildChannel import dev.kord.core.supplier.EntitySupplier import dev.kord.core.supplier.EntitySupplyStrategy -// TODO missing vals, AutoModerationAction - public sealed class AutoModerationRule( public val data: AutoModerationRuleData, final override val kord: Kord, @@ -25,8 +26,12 @@ public sealed class AutoModerationRule( ) : TypedAutoModerationRuleBehavior { init { - expectedTriggerType?.let { - require(data.triggerType == it) { "Wrong trigger type, expected $it but got ${data.triggerType}" } + if (expectedTriggerType == null) { + require(data.triggerType is Unknown) { "Expected unknown trigger type but got ${data.triggerType}" } + } else { + require(data.triggerType == expectedTriggerType) { + "Wrong trigger type, expected $expectedTriggerType but got ${data.triggerType}" + } } } @@ -37,16 +42,34 @@ public sealed class AutoModerationRule( /** The rule name. */ public val name: String get() = data.name + /** The ID of the [Member] which first created this rule. */ public val creatorId: Snowflake get() = data.creatorId + + /** The behavior of the [Member] which first created this rule. */ public val creator: MemberBehavior get() = MemberBehavior(guildId, id = creatorId, kord) + /** The rule [event type][AutoModerationRuleEventType]. */ public val eventType: AutoModerationRuleEventType get() = data.eventType - public val actions: List get() = TODO() + /** The actions which will execute when the rule is triggered. */ + public val actions: List get() = TODO("Add AutoModerationAction") /** Whether the rule is enabled. */ public val isEnabled: Boolean get() = data.enabled + /** The IDs of the [Role]s that should not be affected by the rule. */ + public val exemptRoleIds: List get() = data.exemptRoles + + /** The behaviors of the [Role]s that should not be affected by the rule. */ + public val exemptRoles: List get() = data.exemptRoles.map { RoleBehavior(guildId, id = it, kord) } + + /** The IDs of the [GuildChannel]s that should not be affected by the rule. */ + public val exemptChannelIds: List get() = data.exemptChannels + + /** The behaviors of the [GuildChannel]s that should not be affected by the rule. */ + public val exemptChannels: List + get() = data.exemptChannels.map { GuildChannelBehavior(guildId, id = it, kord) } + abstract override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRule final override fun equals(other: Any?): Boolean = this autoModerationRuleIsEqualTo other @@ -133,10 +156,6 @@ public class KeywordPresetAutoModerationRule(data: AutoModerationRuleData, kord: public class UnknownAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = null) { - init { - require(data.triggerType is Unknown) { "Expected unknown trigger type but got ${data.triggerType}" } - } - override val triggerType: Unknown get() = data.triggerType as Unknown override fun withStrategy(strategy: EntitySupplyStrategy<*>): UnknownAutoModerationRule = From dd215aa8bff1420830a11c887ba87a29fba3475a Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 17 Jul 2022 23:18:36 +0200 Subject: [PATCH 25/57] Add `AutoModerationAction` --- .../automoderation/AutoModerationAction.kt | 80 +++++++++++++++++++ .../automoderation/AutoModerationRule.kt | 2 +- .../AutoModerationActionBuilder.kt | 2 +- 3 files changed, 82 insertions(+), 2 deletions(-) create mode 100644 core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt new file mode 100644 index 000000000000..a7df9d80d985 --- /dev/null +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt @@ -0,0 +1,80 @@ +package dev.kord.core.entity.automoderation + +import dev.kord.common.entity.AutoModerationActionType +import dev.kord.common.entity.AutoModerationActionType.* +import dev.kord.common.entity.Snowflake +import dev.kord.core.cache.data.AutoModerationActionData +import dev.kord.core.entity.channel.GuildChannel +import kotlin.time.Duration + +/** An action which will execute whenever an [AutoModerationRule] is triggered. */ +public sealed class AutoModerationAction( + public val data: AutoModerationActionData, + expectedActionType: AutoModerationActionType?, +) { + init { + if (expectedActionType == null) { + require(data.type is Unknown) { "Expected unknown action type but got ${data.type}" } + } else { + require(data.type == expectedActionType) { + "Wrong action type, expected $expectedActionType but got ${data.type}" + } + } + } + + /** The type of action. */ + public abstract val type: AutoModerationActionType +} + +internal fun AutoModerationAction(data: AutoModerationActionData) = when (data.type) { + BlockMessage -> BlockMessageAutoModerationAction(data) + SendAlertMessage -> SendAlertMessageAutoModerationAction(data) + Timeout -> TimeoutAutoModerationAction(data) + is Unknown -> UnknownAutoModerationAction(data) +} + +/** An [AutoModerationAction] of type [BlockMessage]. */ +public class BlockMessageAutoModerationAction( + data: AutoModerationActionData, +) : AutoModerationAction(data, expectedActionType = BlockMessage) { + + override val type: BlockMessage get() = BlockMessage + + override fun toString(): String = "BlockMessageAutoModerationAction(data=$data)" +} + +/** An [AutoModerationAction] of type [SendAlertMessage]. */ +public class SendAlertMessageAutoModerationAction( + data: AutoModerationActionData, +) : AutoModerationAction(data, expectedActionType = SendAlertMessage) { + + override val type: SendAlertMessage get() = SendAlertMessage + + /** The ID of the [GuildChannel] to which user content should be logged. */ + public val channelId: Snowflake get() = data.metadata.value!!.channelId.value!! + + override fun toString(): String = "SendAlertMessageAutoModerationAction(data=$data)" +} + +/** An [AutoModerationAction] of type [Timeout]. */ +public class TimeoutAutoModerationAction( + data: AutoModerationActionData, +) : AutoModerationAction(data, expectedActionType = Timeout) { + + override val type: Timeout get() = Timeout + + /** The timeout duration. */ + public val duration: Duration get() = data.metadata.value!!.durationSeconds.value!! + + override fun toString(): String = "TimeoutAutoModerationAction(data=$data)" +} + +/** An [AutoModerationAction] of type [Unknown]. */ +public class UnknownAutoModerationAction( + data: AutoModerationActionData, +) : AutoModerationAction(data, expectedActionType = null) { + + override val type: Unknown get() = data.type as Unknown + + override fun toString(): String = "UnknownAutoModerationAction(data=$data)" +} diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 8357a9c553ac..1077672d05c5 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -52,7 +52,7 @@ public sealed class AutoModerationRule( public val eventType: AutoModerationRuleEventType get() = data.eventType /** The actions which will execute when the rule is triggered. */ - public val actions: List get() = TODO("Add AutoModerationAction") + public val actions: List get() = data.actions.map { AutoModerationAction(it) } /** Whether the rule is enabled. */ public val isEnabled: Boolean get() = data.enabled diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt index 5db39fd739e2..5ddafb26db52 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt @@ -34,7 +34,7 @@ public class BlockMessageAutoModerationActionBuilder : AutoModerationActionBuild @KordDsl public class SendAlertMessageAutoModerationActionBuilder( - /** ID of the channel to which user content should be logged. */ + /** The ID of the channel to which user content should be logged. */ public var channelId: Snowflake, ) : AutoModerationActionBuilder() { From 2c9e9a2b07946198f8186e9cfba6fdd501a7198c Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 17 Jul 2022 23:42:02 +0200 Subject: [PATCH 26/57] Add docs for `AutoModerationRule` --- .../AutoModerationRuleBehavior.kt | 1 - .../automoderation/AutoModerationRule.kt | 20 ++++++++++++++----- 2 files changed, 15 insertions(+), 6 deletions(-) diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index 2ad25ef6e505..822fc9696ac1 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -9,7 +9,6 @@ import dev.kord.core.entity.Guild import dev.kord.core.entity.KordEntity import dev.kord.core.entity.Strategizable import dev.kord.core.entity.automoderation.* -import dev.kord.core.entity.automoderation.AutoModerationRule import dev.kord.core.supplier.EntitySupplyStrategy import dev.kord.rest.builder.automoderation.* import java.util.Objects diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 1077672d05c5..5d38ed8cad8e 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -12,12 +12,22 @@ import dev.kord.core.behavior.RoleBehavior import dev.kord.core.behavior.automoderation.* import dev.kord.core.behavior.channel.GuildChannelBehavior import dev.kord.core.cache.data.AutoModerationRuleData +import dev.kord.core.entity.Guild import dev.kord.core.entity.Member import dev.kord.core.entity.Role import dev.kord.core.entity.channel.GuildChannel import dev.kord.core.supplier.EntitySupplier import dev.kord.core.supplier.EntitySupplyStrategy +/** + * An instance of a [Discord Auto Moderation Rule](https://discord.com/developers/docs/resources/auto-moderation). + * + * Auto Moderation is a feature which allows each [Guild] to set up rules that trigger based on some criteria. For + * example, a rule can trigger whenever a message contains a specific keyword. + * + * Rules can be configured to automatically execute actions whenever they trigger. For example, if a user tries to send + * a message which contains a certain keyword, a rule can trigger and block the message before it is sent. + */ public sealed class AutoModerationRule( public val data: AutoModerationRuleData, final override val kord: Kord, @@ -89,7 +99,7 @@ internal fun AutoModerationRule( is Unknown -> UnknownAutoModerationRule(data, kord, supplier) } - +/** An [AutoModerationRule] with trigger type [Keyword]. */ public class KeywordAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = Keyword), KeywordAutoModerationRuleBehavior { @@ -109,7 +119,7 @@ public class KeywordAutoModerationRule(data: AutoModerationRuleData, kord: Kord, override fun toString(): String = "KeywordAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" } - +/** An [AutoModerationRule] with trigger type [HarmfulLink]. */ public class HarmfulLinkAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = HarmfulLink), HarmfulLinkAutoModerationRuleBehavior { @@ -120,7 +130,7 @@ public class HarmfulLinkAutoModerationRule(data: AutoModerationRuleData, kord: K override fun toString(): String = "HarmfulLinkAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" } - +/** An [AutoModerationRule] with trigger type [Spam]. */ public class SpamAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = Spam), SpamAutoModerationRuleBehavior { @@ -131,7 +141,7 @@ public class SpamAutoModerationRule(data: AutoModerationRuleData, kord: Kord, su override fun toString(): String = "SpamAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" } - +/** An [AutoModerationRule] with trigger type [KeywordPreset]. */ public class KeywordPresetAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = KeywordPreset), KeywordPresetAutoModerationRuleBehavior { @@ -152,7 +162,7 @@ public class KeywordPresetAutoModerationRule(data: AutoModerationRuleData, kord: override fun toString(): String = "KeywordPresetAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" } - +/** An [AutoModerationRule] with trigger type [Unknown]. */ public class UnknownAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = null) { From 1cdcf291e534983d9816219482ffb4bfe0326a64 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Fri, 22 Jul 2022 02:20:00 +0200 Subject: [PATCH 27/57] Add more documentation --- .../src/main/kotlin/behavior/GuildBehavior.kt | 34 ++++++++++++++- .../AutoModerationRuleBehavior.kt | 43 +++++++++++++++++++ 2 files changed, 75 insertions(+), 2 deletions(-) diff --git a/core/src/main/kotlin/behavior/GuildBehavior.kt b/core/src/main/kotlin/behavior/GuildBehavior.kt index 1ba9de88f091..6134d53395c9 100644 --- a/core/src/main/kotlin/behavior/GuildBehavior.kt +++ b/core/src/main/kotlin/behavior/GuildBehavior.kt @@ -5,6 +5,7 @@ import dev.kord.common.annotation.DeprecatedSinceKord import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.* import dev.kord.common.entity.AutoModerationRuleEventType.MessageSend +import dev.kord.common.entity.Permission.ManageGuild import dev.kord.common.entity.optional.Optional import dev.kord.common.entity.optional.unwrap import dev.kord.common.exception.RequestException @@ -56,7 +57,7 @@ import dev.kord.rest.request.RestRequestException import dev.kord.rest.service.* import kotlinx.coroutines.flow.* import kotlinx.datetime.Instant -import java.util.* +import java.util.Objects import kotlin.contracts.InvocationKind import kotlin.contracts.InvocationKind.EXACTLY_ONCE import kotlin.contracts.contract @@ -320,6 +321,7 @@ public interface GuildBehavior : KordEntity, Strategizable { /** * Requests to edit this guild's [MFA level][MFALevel] and returns the updated level. + * * This requires guild ownership. * * @throws RestRequestException if something went wrong during the request. @@ -1059,8 +1061,15 @@ public suspend fun GuildBehavior.createScheduledEvent( return GuildScheduledEvent(data, kord, supplier) } -// TODO documentation +// TODO list rules, get rule (via supplier) +/** + * Requests to create a new [KeywordAutoModerationRule] in this guild and returns it. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun GuildBehavior.createKeywordAutoModerationRule( name: String, eventType: AutoModerationRuleEventType = MessageSend, @@ -1071,6 +1080,13 @@ public suspend inline fun GuildBehavior.createKeywordAutoModerationRule( return KeywordAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) } +/** + * Requests to create a new [HarmfulLinkAutoModerationRule] in this guild and returns it. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun GuildBehavior.createHarmfulLinkAutoModerationRule( name: String, eventType: AutoModerationRuleEventType = MessageSend, @@ -1081,6 +1097,13 @@ public suspend inline fun GuildBehavior.createHarmfulLinkAutoModerationRule( return HarmfulLinkAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) } +/** + * Requests to create a new [SpamAutoModerationRule] in this guild and returns it. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun GuildBehavior.createSpamAutoModerationRule( name: String, eventType: AutoModerationRuleEventType = MessageSend, @@ -1091,6 +1114,13 @@ public suspend inline fun GuildBehavior.createSpamAutoModerationRule( return SpamAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) } +/** + * Requests to create a new [KeywordPresetAutoModerationRule] in this guild and returns it. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun GuildBehavior.createKeywordPresetAutoModerationRule( name: String, eventType: AutoModerationRuleEventType = MessageSend, diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index 822fc9696ac1..5a85cdd7baf0 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -2,6 +2,7 @@ package dev.kord.core.behavior.automoderation import dev.kord.common.entity.AutoModerationRuleTriggerType import dev.kord.common.entity.AutoModerationRuleTriggerType.* +import dev.kord.common.entity.Permission.ManageGuild import dev.kord.common.entity.Snowflake import dev.kord.core.behavior.GuildBehavior import dev.kord.core.cache.data.AutoModerationRuleData @@ -11,12 +12,14 @@ import dev.kord.core.entity.Strategizable import dev.kord.core.entity.automoderation.* import dev.kord.core.supplier.EntitySupplyStrategy import dev.kord.rest.builder.automoderation.* +import dev.kord.rest.request.RestRequestException import java.util.Objects import kotlin.contracts.InvocationKind.EXACTLY_ONCE import kotlin.contracts.contract // TODO documentation, missing vals/funs, factory methods, creation from unsafe +/** The behavior of an [AutoModerationRule]. */ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { /** The ID of the [Guild] which this rule belongs to. */ @@ -36,6 +39,13 @@ internal infix fun AutoModerationRuleBehavior.autoModerationRuleIsEqualTo(other: internal fun AutoModerationRuleBehavior.hashAutoModerationRule() = Objects.hash(id, guildId) +/** + * Requests to edit this [AutoModerationRule] and returns the edited rule. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun AutoModerationRuleBehavior.edit( builder: UntypedAutoModerationRuleModifyBuilder.() -> Unit, ): AutoModerationRule { @@ -45,17 +55,26 @@ public suspend inline fun AutoModerationRuleBehavior.edit( } +/** An [AutoModerationRuleBehavior] with a non-null [triggerType]. */ public interface TypedAutoModerationRuleBehavior : AutoModerationRuleBehavior { override val triggerType: AutoModerationRuleTriggerType override fun withStrategy(strategy: EntitySupplyStrategy<*>): TypedAutoModerationRuleBehavior } +/** The behavior of a [KeywordAutoModerationRule]. */ public interface KeywordAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { override val triggerType: Keyword get() = Keyword override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordAutoModerationRuleBehavior } +/** + * Requests to edit this [KeywordAutoModerationRule] and returns the edited rule. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun KeywordAutoModerationRuleBehavior.edit( builder: KeywordAutoModerationRuleModifyBuilder.() -> Unit, ): KeywordAutoModerationRule { @@ -65,11 +84,19 @@ public suspend inline fun KeywordAutoModerationRuleBehavior.edit( } +/** The behavior of a [HarmfulLinkAutoModerationRule]. */ public interface HarmfulLinkAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { override val triggerType: HarmfulLink get() = HarmfulLink override fun withStrategy(strategy: EntitySupplyStrategy<*>): HarmfulLinkAutoModerationRuleBehavior } +/** + * Requests to edit this [HarmfulLinkAutoModerationRule] and returns the edited rule. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun HarmfulLinkAutoModerationRuleBehavior.edit( builder: HarmfulLinkAutoModerationRuleModifyBuilder.() -> Unit, ): HarmfulLinkAutoModerationRule { @@ -79,11 +106,19 @@ public suspend inline fun HarmfulLinkAutoModerationRuleBehavior.edit( } +/** The behavior of a [SpamAutoModerationRule]. */ public interface SpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { override val triggerType: Spam get() = Spam override fun withStrategy(strategy: EntitySupplyStrategy<*>): SpamAutoModerationRuleBehavior } +/** + * Requests to edit this [SpamAutoModerationRule] and returns the edited rule. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun SpamAutoModerationRuleBehavior.edit( builder: SpamAutoModerationRuleModifyBuilder.() -> Unit, ): SpamAutoModerationRule { @@ -93,11 +128,19 @@ public suspend inline fun SpamAutoModerationRuleBehavior.edit( } +/** The behavior of a [KeywordPresetAutoModerationRule]. */ public interface KeywordPresetAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { override val triggerType: KeywordPreset get() = KeywordPreset override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordPresetAutoModerationRuleBehavior } +/** + * Requests to edit this [KeywordPresetAutoModerationRule] and returns the edited rule. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ public suspend inline fun KeywordPresetAutoModerationRuleBehavior.edit( builder: KeywordPresetAutoModerationRuleModifyBuilder.() -> Unit, ): KeywordPresetAutoModerationRule { From 73e70ad2f1d0df98ccb82b9bb38789b5a8ef0e5c Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Fri, 22 Jul 2022 02:25:32 +0200 Subject: [PATCH 28/57] Add `AutoModerationRuleBehavior.delete` --- .../automoderation/AutoModerationRuleBehavior.kt | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index 5a85cdd7baf0..b6e38957c038 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -17,7 +17,7 @@ import java.util.Objects import kotlin.contracts.InvocationKind.EXACTLY_ONCE import kotlin.contracts.contract -// TODO documentation, missing vals/funs, factory methods, creation from unsafe +// TODO factory methods, creation from unsafe /** The behavior of an [AutoModerationRule]. */ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { @@ -31,6 +31,18 @@ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { /** The rule [trigger type][AutoModerationRuleTriggerType]. */ public val triggerType: AutoModerationRuleTriggerType? + /** + * Requests to delete this [AutoModerationRule]. + * + * This requires the [ManageGuild] permission. + * + * @param reason the reason showing up in the audit log + * @throws RestRequestException if something went wrong during the request. + */ + public suspend fun delete(reason: String? = null) { + kord.rest.autoModeration.deleteAutoModerationRule(guildId, ruleId = id, reason) + } + override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleBehavior } From 85087ed585a1ce4450f1e3f5f9d3d0eb4ce63664 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Thu, 28 Jul 2022 23:52:34 +0200 Subject: [PATCH 29/57] Add @suppress to `assignX()` implementations --- .../automoderation/AutoModerationRuleCreateBuilder.kt | 8 ++++++++ .../automoderation/AutoModerationRuleModifyBuilder.kt | 11 +++++++++++ 2 files changed, 19 insertions(+) diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt index 16fb08dfab75..b655a56f5189 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt @@ -20,10 +20,12 @@ public sealed class AutoModerationRuleCreateBuilder( ) : TypedAutoModerationRuleBuilder, AuditRequestBuilder { final override var reason: String? = null + /** @suppress */ // don't include in documentation, `name` is overridden to be `var` final override fun assignName(name: String) { this.name = name } + /** @suppress */ // don't include in documentation, `eventType` is overridden to be `var` final override fun assignEventType(eventType: AutoModerationRuleEventType) { this.eventType = eventType } @@ -31,6 +33,8 @@ public sealed class AutoModerationRuleCreateBuilder( protected open fun buildTriggerMetadata(): Optional = Optional.Missing() final override var actions: MutableList = mutableListOf() + + /** @suppress */ // don't include in documentation, `actions` is overridden to be `var` final override fun assignActions(actions: MutableList) { this.actions = actions } @@ -63,6 +67,8 @@ public class KeywordAutoModerationRuleCreateBuilder( ) : AutoModerationRuleCreateBuilder(name, eventType), KeywordAutoModerationRuleBuilder { override var keywords: MutableList = mutableListOf() + + /** @suppress */ // don't include in documentation, `keywords` is overridden to be `var` override fun assignKeywords(keywords: MutableList) { this.keywords = keywords } @@ -90,6 +96,8 @@ public class KeywordPresetAutoModerationRuleCreateBuilder( ) : AutoModerationRuleCreateBuilder(name, eventType), KeywordPresetAutoModerationRuleBuilder { override var presets: MutableList = mutableListOf() + + /** @suppress */ // don't include in documentation, `presets` is overridden to be `var` override fun assignPresets(presets: MutableList) { this.presets = presets } diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt index b113e20fa7f4..5b338217888e 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt @@ -15,12 +15,16 @@ public sealed class AutoModerationRuleModifyBuilder : private var _name: Optional = Optional.Missing() final override var name: String? by ::_name.delegate() + + /** @suppress */ // don't include in documentation, `name` is overridden to be `var` final override fun assignName(name: String) { this.name = name } private var _eventType: Optional = Optional.Missing() final override var eventType: AutoModerationRuleEventType? by ::_eventType.delegate() + + /** @suppress */ // don't include in documentation, `eventType` is overridden to be `var` final override fun assignEventType(eventType: AutoModerationRuleEventType) { this.eventType = eventType } @@ -29,6 +33,8 @@ public sealed class AutoModerationRuleModifyBuilder : private var _actions: Optional> = Optional.Missing() final override var actions: MutableList? by ::_actions.delegate() + + /** @suppress */ // don't include in documentation, `actions` is overridden to be `var` final override fun assignActions(actions: MutableList) { this.actions = actions } @@ -70,6 +76,8 @@ public class KeywordAutoModerationRuleModifyBuilder : private var _keywords: Optional> = Optional.Missing() override var keywords: MutableList? by ::_keywords.delegate() + + /** @suppress */ // don't include in documentation, `keywords` is overridden to be `var` override fun assignKeywords(keywords: MutableList) { this.keywords = keywords } @@ -97,6 +105,8 @@ public class KeywordPresetAutoModerationRuleModifyBuilder : private var _presets: Optional> = Optional.Missing() override var presets: MutableList? by ::_presets.delegate() + + /** @suppress */ // don't include in documentation, `presets` is overridden to be `var` override fun assignPresets(presets: MutableList) { this.presets = presets } @@ -112,6 +122,7 @@ public class KeywordPresetAutoModerationRuleModifyBuilder : presets = presets.map { it.toList() }, allowList = allowList.map { it.toList() }, ).optional() + else -> Optional.Missing() } } From 65fc3e79bb940bb13a8de61cbd0c230397eb6361 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Fri, 29 Jul 2022 19:37:49 +0200 Subject: [PATCH 30/57] Retrieve rules via suppliers --- .../src/main/kotlin/behavior/GuildBehavior.kt | 39 ++++++++++++-- .../automoderation/AutoModerationRule.kt | 2 +- .../exception/EntityNotFoundException.kt | 3 ++ .../kotlin/supplier/CacheEntitySupplier.kt | 15 ++++++ .../main/kotlin/supplier/EntitySupplier.kt | 7 +++ .../kotlin/supplier/FallbackEntitySupplier.kt | 8 +++ .../kotlin/supplier/RestEntitySupplier.kt | 54 ++++++++++++++----- .../kotlin/supplier/StoreEntitySupplier.kt | 8 +++ 8 files changed, 116 insertions(+), 20 deletions(-) diff --git a/core/src/main/kotlin/behavior/GuildBehavior.kt b/core/src/main/kotlin/behavior/GuildBehavior.kt index 1c80c56c513a..9c136283a71c 100644 --- a/core/src/main/kotlin/behavior/GuildBehavior.kt +++ b/core/src/main/kotlin/behavior/GuildBehavior.kt @@ -18,10 +18,7 @@ import dev.kord.core.entity.application.GuildApplicationCommand import dev.kord.core.entity.application.GuildChatInputCommand import dev.kord.core.entity.application.GuildMessageCommand import dev.kord.core.entity.application.GuildUserCommand -import dev.kord.core.entity.automoderation.HarmfulLinkAutoModerationRule -import dev.kord.core.entity.automoderation.KeywordAutoModerationRule -import dev.kord.core.entity.automoderation.KeywordPresetAutoModerationRule -import dev.kord.core.entity.automoderation.SpamAutoModerationRule +import dev.kord.core.entity.automoderation.* import dev.kord.core.entity.channel.* import dev.kord.core.entity.channel.thread.ThreadChannel import dev.kord.core.event.guild.MembersChunkEvent @@ -621,6 +618,39 @@ public interface GuildBehavior : KordEntity, Strategizable { return GuildSticker(data, kord) } + /** + * Requests to get all [AutoModerationRule]s currently configured for this guild. + * + * This requires the [ManageGuild] permission. + * + * The returned flow is lazily executed, any [RequestException] will be thrown on + * [terminal operators](https://kotlinlang.org/docs/reference/coroutines/flow.html#terminal-flow-operators) instead. + */ + public val autoModerationRules: Flow + get() = supplier.getAutoModerationRules(guildId = id) + + /** + * Requests an [AutoModerationRule] by its [id][ruleId]. Returns `null` if it wasn't found. + * + * This requires the [ManageGuild] permission. + * + * @throws RequestException if something went wrong during the request. + */ + public suspend fun getAutoModerationRuleOrNull(ruleId: Snowflake): AutoModerationRule? = + supplier.getAutoModerationRuleOrNull(guildId = id, ruleId) + + /** + * Requests an [AutoModerationRule] by its [id][ruleId]. + * + * This requires the [ManageGuild] permission. + * + * @throws RequestException if something went wrong during the request. + * @throws EntityNotFoundException if the [AutoModerationRule] wasn't found. + */ + public suspend fun getAutoModerationRule(ruleId: Snowflake): AutoModerationRule = + supplier.getAutoModerationRule(guildId = id, ruleId) + + /** * Returns a new [GuildBehavior] with the given [strategy]. */ @@ -1064,7 +1094,6 @@ public suspend fun GuildBehavior.createScheduledEvent( return GuildScheduledEvent(data, kord, supplier) } -// TODO list rules, get rule (via supplier) /** * Requests to create a new [KeywordAutoModerationRule] in this guild and returns it. diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 5d38ed8cad8e..6b99db3446f3 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -90,7 +90,7 @@ public sealed class AutoModerationRule( internal fun AutoModerationRule( data: AutoModerationRuleData, kord: Kord, - supplier: EntitySupplier, + supplier: EntitySupplier = kord.defaultSupplier, ): AutoModerationRule = when (data.triggerType) { Keyword -> KeywordAutoModerationRule(data, kord, supplier) HarmfulLink -> HarmfulLinkAutoModerationRule(data, kord, supplier) diff --git a/core/src/main/kotlin/exception/EntityNotFoundException.kt b/core/src/main/kotlin/exception/EntityNotFoundException.kt index 70be3444c478..a8747b3cf664 100644 --- a/core/src/main/kotlin/exception/EntityNotFoundException.kt +++ b/core/src/main/kotlin/exception/EntityNotFoundException.kt @@ -98,5 +98,8 @@ public class EntityNotFoundException : Exception { throw EntityNotFoundException( "Followup message with id $messageId for interaction with token $token was not found." ) + + public inline fun autoModerationRuleNotFound(guildId: Snowflake, ruleId: Snowflake): Nothing = + guildEntityNotFound("Auto Moderation Rule", guildId, ruleId) } } diff --git a/core/src/main/kotlin/supplier/CacheEntitySupplier.kt b/core/src/main/kotlin/supplier/CacheEntitySupplier.kt index 04debe6b0b71..f5634aad5533 100644 --- a/core/src/main/kotlin/supplier/CacheEntitySupplier.kt +++ b/core/src/main/kotlin/supplier/CacheEntitySupplier.kt @@ -15,6 +15,7 @@ import dev.kord.core.entity.* import dev.kord.core.entity.application.ApplicationCommandPermissions import dev.kord.core.entity.application.GlobalApplicationCommand import dev.kord.core.entity.application.GuildApplicationCommand +import dev.kord.core.entity.automoderation.AutoModerationRule import dev.kord.core.entity.channel.Channel import dev.kord.core.entity.channel.TopGuildChannel import dev.kord.core.entity.channel.thread.ThreadChannel @@ -584,6 +585,20 @@ public class CacheEntitySupplier(private val kord: Kord) : EntitySupplier { idEq(GuildScheduledEventData::guildId, guildId) }.asFlow().map { GuildScheduledEvent(it, kord) } + override fun getAutoModerationRules(guildId: Snowflake): Flow = + cache.query { idEq(AutoModerationRuleData::guildId, guildId) } + .asFlow() + .map { AutoModerationRule(it, kord) } + + override suspend fun getAutoModerationRuleOrNull(guildId: Snowflake, ruleId: Snowflake): AutoModerationRule? = + cache + .query { + idEq(AutoModerationRuleData::id, ruleId) + idEq(AutoModerationRuleData::guildId, guildId) + } + .singleOrNull() + ?.let { AutoModerationRule(it, kord) } + override fun toString(): String = "CacheEntitySupplier(cache=$cache)" } diff --git a/core/src/main/kotlin/supplier/EntitySupplier.kt b/core/src/main/kotlin/supplier/EntitySupplier.kt index 8d3541e61e40..8cf91ef70d44 100644 --- a/core/src/main/kotlin/supplier/EntitySupplier.kt +++ b/core/src/main/kotlin/supplier/EntitySupplier.kt @@ -7,6 +7,7 @@ import dev.kord.core.entity.* import dev.kord.core.entity.application.ApplicationCommandPermissions import dev.kord.core.entity.application.GlobalApplicationCommand import dev.kord.core.entity.application.GuildApplicationCommand +import dev.kord.core.entity.automoderation.AutoModerationRule import dev.kord.core.entity.channel.Channel import dev.kord.core.entity.channel.MessageChannel import dev.kord.core.entity.channel.TopGuildChannel @@ -609,6 +610,12 @@ public interface EntitySupplier { public fun getNitroStickerPacks(): Flow public fun getGuildStickers(guildId: Snowflake): Flow + + public fun getAutoModerationRules(guildId: Snowflake): Flow + public suspend fun getAutoModerationRuleOrNull(guildId: Snowflake, ruleId: Snowflake): AutoModerationRule? + public suspend fun getAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): AutoModerationRule = + getAutoModerationRuleOrNull(guildId, ruleId) + ?: EntityNotFoundException.autoModerationRuleNotFound(guildId, ruleId) } diff --git a/core/src/main/kotlin/supplier/FallbackEntitySupplier.kt b/core/src/main/kotlin/supplier/FallbackEntitySupplier.kt index 01d25b03fe1d..73e532554b93 100644 --- a/core/src/main/kotlin/supplier/FallbackEntitySupplier.kt +++ b/core/src/main/kotlin/supplier/FallbackEntitySupplier.kt @@ -5,6 +5,7 @@ import dev.kord.core.entity.* import dev.kord.core.entity.application.ApplicationCommandPermissions import dev.kord.core.entity.application.GlobalApplicationCommand import dev.kord.core.entity.application.GuildApplicationCommand +import dev.kord.core.entity.automoderation.AutoModerationRule import dev.kord.core.entity.channel.Channel import dev.kord.core.entity.channel.TopGuildChannel import dev.kord.core.entity.channel.thread.ThreadChannel @@ -270,5 +271,12 @@ private class FallbackEntitySupplier(val first: EntitySupplier, val second: Enti first.getGuildStickers(guildId).switchIfEmpty(second.getGuildStickers(guildId)) + override fun getAutoModerationRules(guildId: Snowflake): Flow = + first.getAutoModerationRules(guildId).switchIfEmpty(second.getAutoModerationRules(guildId)) + + override suspend fun getAutoModerationRuleOrNull(guildId: Snowflake, ruleId: Snowflake): AutoModerationRule? = + first.getAutoModerationRuleOrNull(guildId, ruleId) ?: second.getAutoModerationRuleOrNull(guildId, ruleId) + + override fun toString(): String = "FallbackEntitySupplier(first=$first, second=$second)" } diff --git a/core/src/main/kotlin/supplier/RestEntitySupplier.kt b/core/src/main/kotlin/supplier/RestEntitySupplier.kt index 41bc8cb3b216..e8cf4dcf7780 100644 --- a/core/src/main/kotlin/supplier/RestEntitySupplier.kt +++ b/core/src/main/kotlin/supplier/RestEntitySupplier.kt @@ -10,6 +10,7 @@ import dev.kord.core.entity.* import dev.kord.core.entity.application.ApplicationCommandPermissions import dev.kord.core.entity.application.GlobalApplicationCommand import dev.kord.core.entity.application.GuildApplicationCommand +import dev.kord.core.entity.automoderation.AutoModerationRule import dev.kord.core.entity.channel.Channel import dev.kord.core.entity.channel.TopGuildChannel import dev.kord.core.entity.channel.thread.ThreadChannel @@ -23,7 +24,7 @@ import dev.kord.rest.json.request.ListThreadsBySnowflakeRequest import dev.kord.rest.json.request.ListThreadsByTimestampRequest import dev.kord.rest.request.RestRequestException import dev.kord.rest.route.Position -import dev.kord.rest.service.* +import dev.kord.rest.service.RestClient import kotlinx.coroutines.flow.* import kotlinx.datetime.Instant import kotlin.contracts.InvocationKind @@ -41,19 +42,28 @@ import kotlin.math.min */ public class RestEntitySupplier(public val kord: Kord) : EntitySupplier { - private inline val auditLog: AuditLogService get() = kord.rest.auditLog - private inline val channel: ChannelService get() = kord.rest.channel - private inline val emoji: EmojiService get() = kord.rest.emoji - private inline val guild: GuildService get() = kord.rest.guild - private inline val invite: InviteService get() = kord.rest.invite - private inline val user: UserService get() = kord.rest.user - private inline val voice: VoiceService get() = kord.rest.voice - private inline val webhook: WebhookService get() = kord.rest.webhook - private inline val application: ApplicationService get() = kord.rest.application - private inline val template: TemplateService get() = kord.rest.template - private inline val interaction: InteractionService get() = kord.rest.interaction - private inline val stageInstance: StageInstanceService get() = kord.rest.stageInstance - private inline val sticker: StickerService get() = kord.rest.sticker + // order like in docs: + + // interactions + private inline val interaction get() = kord.rest.interaction + + // resources + private inline val auditLog get() = kord.rest.auditLog + private inline val autoModeration get() = kord.rest.autoModeration + private inline val channel get() = kord.rest.channel + private inline val emoji get() = kord.rest.emoji + private inline val guild get() = kord.rest.guild + private inline val template get() = kord.rest.template + private inline val invite get() = kord.rest.invite + private inline val stageInstance get() = kord.rest.stageInstance + private inline val sticker get() = kord.rest.sticker + private inline val user get() = kord.rest.user + private inline val voice get() = kord.rest.voice + private inline val webhook get() = kord.rest.webhook + + // topics + private inline val application get() = kord.rest.application + // max batchSize/limit: see https://discord.com/developers/docs/resources/user#get-current-user-guilds override val guilds: Flow @@ -579,6 +589,22 @@ public class RestEntitySupplier(public val kord: Kord) : EntitySupplier { } } + override fun getAutoModerationRules(guildId: Snowflake): Flow = flow { + val responses = autoModeration.listAutoModerationRulesForGuild(guildId) + + responses.forEach { response -> + val data = AutoModerationRuleData.from(response) + emit(AutoModerationRule(data, kord)) + } + } + + override suspend fun getAutoModerationRuleOrNull(guildId: Snowflake, ruleId: Snowflake): AutoModerationRule? = + catchNotFound { + val response = autoModeration.getAutoModerationRule(guildId, ruleId) + val data = AutoModerationRuleData.from(response) + AutoModerationRule(data, kord) + } + override suspend fun getApplicationCommandPermissionsOrNull( applicationId: Snowflake, guildId: Snowflake, diff --git a/core/src/main/kotlin/supplier/StoreEntitySupplier.kt b/core/src/main/kotlin/supplier/StoreEntitySupplier.kt index 42a45f08d1d0..5bcd064ee531 100644 --- a/core/src/main/kotlin/supplier/StoreEntitySupplier.kt +++ b/core/src/main/kotlin/supplier/StoreEntitySupplier.kt @@ -8,6 +8,7 @@ import dev.kord.core.entity.* import dev.kord.core.entity.application.ApplicationCommandPermissions import dev.kord.core.entity.application.GlobalApplicationCommand import dev.kord.core.entity.application.GuildApplicationCommand +import dev.kord.core.entity.automoderation.AutoModerationRule import dev.kord.core.entity.channel.Channel import dev.kord.core.entity.channel.TopGuildChannel import dev.kord.core.entity.channel.thread.ThreadChannel @@ -308,6 +309,13 @@ public class StoreEntitySupplier( return storeOnEach(supplier.getGuildApplicationCommandPermissions(applicationId, guildId)) { it.data } } + override fun getAutoModerationRules(guildId: Snowflake): Flow = + storeOnEach(supplier.getAutoModerationRules(guildId)) { it.data } + + override suspend fun getAutoModerationRuleOrNull(guildId: Snowflake, ruleId: Snowflake): AutoModerationRule? = + storeAndReturn(supplier.getAutoModerationRuleOrNull(guildId, ruleId)) { it.data } + + private inline fun storeOnEach(source: Flow, crossinline transform: (T) -> R): Flow { return source.onEach { fetchedEntity -> storeAndReturn(fetchedEntity) { transform(it) } From 4a85adf583685ce0a22b4f077adb1048d74e2633 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 31 Jul 2022 17:06:17 +0200 Subject: [PATCH 31/57] Add `AutoModerationRuleBehavior.asAutoModerationRuleOrNull()` and `AutoModerationRuleBehavior.asAutoModerationRule()` --- .../AutoModerationRuleBehavior.kt | 102 ++++++++++++++++++ .../automoderation/AutoModerationRule.kt | 30 ++++++ 2 files changed, 132 insertions(+) diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index b6e38957c038..fbfd362413a5 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -4,12 +4,14 @@ import dev.kord.common.entity.AutoModerationRuleTriggerType import dev.kord.common.entity.AutoModerationRuleTriggerType.* import dev.kord.common.entity.Permission.ManageGuild import dev.kord.common.entity.Snowflake +import dev.kord.common.exception.RequestException import dev.kord.core.behavior.GuildBehavior import dev.kord.core.cache.data.AutoModerationRuleData import dev.kord.core.entity.Guild import dev.kord.core.entity.KordEntity import dev.kord.core.entity.Strategizable import dev.kord.core.entity.automoderation.* +import dev.kord.core.exception.EntityNotFoundException import dev.kord.core.supplier.EntitySupplyStrategy import dev.kord.rest.builder.automoderation.* import dev.kord.rest.request.RestRequestException @@ -31,6 +33,22 @@ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { /** The rule [trigger type][AutoModerationRuleTriggerType]. */ public val triggerType: AutoModerationRuleTriggerType? + /** + * Requests to get this behavior as an [AutoModerationRule]. Returns `null` if it wasn't found. + * + * @throws RequestException if anything went wrong during the request. + */ + public suspend fun asAutoModerationRuleOrNull(): AutoModerationRule? = + supplier.getAutoModerationRuleOrNull(guildId, ruleId = id) + + /** + * Requests to get this behavior as an [AutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + * @throws EntityNotFoundException if the [AutoModerationRule] wasn't found. + */ + public suspend fun asAutoModerationRule(): AutoModerationRule = supplier.getAutoModerationRule(guildId, ruleId = id) + /** * Requests to delete this [AutoModerationRule]. * @@ -76,7 +94,28 @@ public interface TypedAutoModerationRuleBehavior : AutoModerationRuleBehavior { /** The behavior of a [KeywordAutoModerationRule]. */ public interface KeywordAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + override val triggerType: Keyword get() = Keyword + + /** + * Requests to get this behavior as a [KeywordAutoModerationRule]. + * Returns `null` if it wasn't found or if the rule isn't a [KeywordAutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + */ + override suspend fun asAutoModerationRuleOrNull(): KeywordAutoModerationRule? = + super.asAutoModerationRuleOrNull() as? KeywordAutoModerationRule + + /** + * Requests to get this behavior as a [KeywordAutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + * @throws EntityNotFoundException if the [KeywordAutoModerationRule] wasn't found. + * @throws ClassCastException if the rule isn't a [KeywordAutoModerationRule]. + */ + override suspend fun asAutoModerationRule(): KeywordAutoModerationRule = + super.asAutoModerationRule() as KeywordAutoModerationRule + override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordAutoModerationRuleBehavior } @@ -98,7 +137,28 @@ public suspend inline fun KeywordAutoModerationRuleBehavior.edit( /** The behavior of a [HarmfulLinkAutoModerationRule]. */ public interface HarmfulLinkAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + override val triggerType: HarmfulLink get() = HarmfulLink + + /** + * Requests to get this behavior as a [HarmfulLinkAutoModerationRule]. + * Returns `null` if it wasn't found or if the rule isn't a [HarmfulLinkAutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + */ + override suspend fun asAutoModerationRuleOrNull(): HarmfulLinkAutoModerationRule? = + super.asAutoModerationRuleOrNull() as? HarmfulLinkAutoModerationRule + + /** + * Requests to get this behavior as a [HarmfulLinkAutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + * @throws EntityNotFoundException if the [HarmfulLinkAutoModerationRule] wasn't found. + * @throws ClassCastException if the rule isn't a [HarmfulLinkAutoModerationRule]. + */ + override suspend fun asAutoModerationRule(): HarmfulLinkAutoModerationRule = + super.asAutoModerationRule() as HarmfulLinkAutoModerationRule + override fun withStrategy(strategy: EntitySupplyStrategy<*>): HarmfulLinkAutoModerationRuleBehavior } @@ -120,7 +180,28 @@ public suspend inline fun HarmfulLinkAutoModerationRuleBehavior.edit( /** The behavior of a [SpamAutoModerationRule]. */ public interface SpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + override val triggerType: Spam get() = Spam + + /** + * Requests to get this behavior as a [SpamAutoModerationRule]. + * Returns `null` if it wasn't found or if the rule isn't a [SpamAutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + */ + override suspend fun asAutoModerationRuleOrNull(): SpamAutoModerationRule? = + super.asAutoModerationRuleOrNull() as? SpamAutoModerationRule + + /** + * Requests to get this behavior as a [SpamAutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + * @throws EntityNotFoundException if the [SpamAutoModerationRule] wasn't found. + * @throws ClassCastException if the rule isn't a [SpamAutoModerationRule]. + */ + override suspend fun asAutoModerationRule(): SpamAutoModerationRule = + super.asAutoModerationRule() as SpamAutoModerationRule + override fun withStrategy(strategy: EntitySupplyStrategy<*>): SpamAutoModerationRuleBehavior } @@ -142,7 +223,28 @@ public suspend inline fun SpamAutoModerationRuleBehavior.edit( /** The behavior of a [KeywordPresetAutoModerationRule]. */ public interface KeywordPresetAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + override val triggerType: KeywordPreset get() = KeywordPreset + + /** + * Requests to get this behavior as a [KeywordPresetAutoModerationRule]. + * Returns `null` if it wasn't found or if the rule isn't a [KeywordPresetAutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + */ + override suspend fun asAutoModerationRuleOrNull(): KeywordPresetAutoModerationRule? = + super.asAutoModerationRuleOrNull() as? KeywordPresetAutoModerationRule + + /** + * Requests to get this behavior as a [KeywordPresetAutoModerationRule]. + * + * @throws RequestException if anything went wrong during the request. + * @throws EntityNotFoundException if the [KeywordPresetAutoModerationRule] wasn't found. + * @throws ClassCastException if the rule isn't a [KeywordPresetAutoModerationRule]. + */ + override suspend fun asAutoModerationRule(): KeywordPresetAutoModerationRule = + super.asAutoModerationRule() as KeywordPresetAutoModerationRule + override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordPresetAutoModerationRuleBehavior } diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 6b99db3446f3..cf8703ad1f26 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -80,10 +80,25 @@ public sealed class AutoModerationRule( public val exemptChannels: List get() = data.exemptChannels.map { GuildChannelBehavior(guildId, id = it, kord) } + /** + * Returns `this`. + * + * @suppress There is no need to call this function. Use `this` directly instead. + */ + abstract override suspend fun asAutoModerationRuleOrNull(): AutoModerationRule + + /** + * Returns `this`. + * + * @suppress There is no need to call this function. Use `this` directly instead. + */ + abstract override suspend fun asAutoModerationRule(): AutoModerationRule + abstract override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRule final override fun equals(other: Any?): Boolean = this autoModerationRuleIsEqualTo other final override fun hashCode(): Int = hashAutoModerationRule() + abstract override fun toString(): String } @PublishedApi @@ -113,6 +128,9 @@ public class KeywordAutoModerationRule(data: AutoModerationRuleData, kord: Kord, */ public val keywords: List get() = data.triggerMetadata.keywordFilter.orEmpty() + override suspend fun asAutoModerationRuleOrNull(): KeywordAutoModerationRule = this + override suspend fun asAutoModerationRule(): KeywordAutoModerationRule = this + override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordAutoModerationRule = KeywordAutoModerationRule(data, kord, strategy.supply(kord)) @@ -124,6 +142,9 @@ public class HarmfulLinkAutoModerationRule(data: AutoModerationRuleData, kord: K AutoModerationRule(data, kord, supplier, expectedTriggerType = HarmfulLink), HarmfulLinkAutoModerationRuleBehavior { + override suspend fun asAutoModerationRuleOrNull(): HarmfulLinkAutoModerationRule = this + override suspend fun asAutoModerationRule(): HarmfulLinkAutoModerationRule = this + override fun withStrategy(strategy: EntitySupplyStrategy<*>): HarmfulLinkAutoModerationRule = HarmfulLinkAutoModerationRule(data, kord, strategy.supply(kord)) @@ -135,6 +156,9 @@ public class SpamAutoModerationRule(data: AutoModerationRuleData, kord: Kord, su AutoModerationRule(data, kord, supplier, expectedTriggerType = Spam), SpamAutoModerationRuleBehavior { + override suspend fun asAutoModerationRuleOrNull(): SpamAutoModerationRule = this + override suspend fun asAutoModerationRule(): SpamAutoModerationRule = this + override fun withStrategy(strategy: EntitySupplyStrategy<*>): SpamAutoModerationRule = SpamAutoModerationRule(data, kord, strategy.supply(kord)) @@ -156,6 +180,9 @@ public class KeywordPresetAutoModerationRule(data: AutoModerationRuleData, kord: */ public val allowList: List get() = data.triggerMetadata.allowList.orEmpty() + override suspend fun asAutoModerationRuleOrNull(): KeywordPresetAutoModerationRule = this + override suspend fun asAutoModerationRule(): KeywordPresetAutoModerationRule = this + override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordPresetAutoModerationRule = KeywordPresetAutoModerationRule(data, kord, strategy.supply(kord)) @@ -168,6 +195,9 @@ public class UnknownAutoModerationRule(data: AutoModerationRuleData, kord: Kord, override val triggerType: Unknown get() = data.triggerType as Unknown + override suspend fun asAutoModerationRuleOrNull(): UnknownAutoModerationRule = this + override suspend fun asAutoModerationRule(): UnknownAutoModerationRule = this + override fun withStrategy(strategy: EntitySupplyStrategy<*>): UnknownAutoModerationRule = UnknownAutoModerationRule(data, kord, strategy.supply(kord)) From 7c1f35e6520ab84ca98dcec04106fa32ea32ede7 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 31 Jul 2022 17:16:32 +0200 Subject: [PATCH 32/57] Add info to `@suppress` tags --- .../automoderation/AutoModerationRuleCreateBuilder.kt | 10 +++++----- .../automoderation/AutoModerationRuleModifyBuilder.kt | 10 +++++----- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt index b655a56f5189..520ec189caf3 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt @@ -20,12 +20,12 @@ public sealed class AutoModerationRuleCreateBuilder( ) : TypedAutoModerationRuleBuilder, AuditRequestBuilder { final override var reason: String? = null - /** @suppress */ // don't include in documentation, `name` is overridden to be `var` + /** @suppress Use `this.name = name` instead. */ final override fun assignName(name: String) { this.name = name } - /** @suppress */ // don't include in documentation, `eventType` is overridden to be `var` + /** @suppress Use `this.eventType = eventType` instead. */ final override fun assignEventType(eventType: AutoModerationRuleEventType) { this.eventType = eventType } @@ -34,7 +34,7 @@ public sealed class AutoModerationRuleCreateBuilder( final override var actions: MutableList = mutableListOf() - /** @suppress */ // don't include in documentation, `actions` is overridden to be `var` + /** @suppress Use `this.actions = actions` instead. */ final override fun assignActions(actions: MutableList) { this.actions = actions } @@ -68,7 +68,7 @@ public class KeywordAutoModerationRuleCreateBuilder( override var keywords: MutableList = mutableListOf() - /** @suppress */ // don't include in documentation, `keywords` is overridden to be `var` + /** @suppress Use `this.keywords = keywords` instead. */ override fun assignKeywords(keywords: MutableList) { this.keywords = keywords } @@ -97,7 +97,7 @@ public class KeywordPresetAutoModerationRuleCreateBuilder( override var presets: MutableList = mutableListOf() - /** @suppress */ // don't include in documentation, `presets` is overridden to be `var` + /** @suppress Use `this.presets = presets` instead. */ override fun assignPresets(presets: MutableList) { this.presets = presets } diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt index 5b338217888e..55a3d1ccc9ae 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt @@ -16,7 +16,7 @@ public sealed class AutoModerationRuleModifyBuilder : private var _name: Optional = Optional.Missing() final override var name: String? by ::_name.delegate() - /** @suppress */ // don't include in documentation, `name` is overridden to be `var` + /** @suppress Use `this.name = name` instead. */ final override fun assignName(name: String) { this.name = name } @@ -24,7 +24,7 @@ public sealed class AutoModerationRuleModifyBuilder : private var _eventType: Optional = Optional.Missing() final override var eventType: AutoModerationRuleEventType? by ::_eventType.delegate() - /** @suppress */ // don't include in documentation, `eventType` is overridden to be `var` + /** @suppress Use `this.eventType = eventType` instead. */ final override fun assignEventType(eventType: AutoModerationRuleEventType) { this.eventType = eventType } @@ -34,7 +34,7 @@ public sealed class AutoModerationRuleModifyBuilder : private var _actions: Optional> = Optional.Missing() final override var actions: MutableList? by ::_actions.delegate() - /** @suppress */ // don't include in documentation, `actions` is overridden to be `var` + /** @suppress Use `this.actions = actions` instead. */ final override fun assignActions(actions: MutableList) { this.actions = actions } @@ -77,7 +77,7 @@ public class KeywordAutoModerationRuleModifyBuilder : private var _keywords: Optional> = Optional.Missing() override var keywords: MutableList? by ::_keywords.delegate() - /** @suppress */ // don't include in documentation, `keywords` is overridden to be `var` + /** @suppress Use `this.keywords = keywords` instead. */ override fun assignKeywords(keywords: MutableList) { this.keywords = keywords } @@ -106,7 +106,7 @@ public class KeywordPresetAutoModerationRuleModifyBuilder : private var _presets: Optional> = Optional.Missing() override var presets: MutableList? by ::_presets.delegate() - /** @suppress */ // don't include in documentation, `presets` is overridden to be `var` + /** @suppress Use `this.presets = presets` instead. */ override fun assignPresets(presets: MutableList) { this.presets = presets } From 19b3a74b2044cb36d7305a9cedb7289d965e338e Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 31 Jul 2022 22:55:53 +0200 Subject: [PATCH 33/57] Add `AutoModerationRuleBehavior.getGuildOrNull()` and `AutoModerationRuleBehavior.getGuild()` --- .../AutoModerationRuleBehavior.kt | 19 +++++++++++++++++-- .../automoderation/AutoModerationRule.kt | 4 ++-- 2 files changed, 19 insertions(+), 4 deletions(-) diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index fbfd362413a5..d0b5f0372a52 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -49,6 +49,21 @@ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { */ public suspend fun asAutoModerationRule(): AutoModerationRule = supplier.getAutoModerationRule(guildId, ruleId = id) + /** + * Requests to get the [Guild] which this rule belongs to. Returns `null` if it wasn't found. + * + * @throws RequestException if anything went wrong during the request. + */ + public suspend fun getGuildOrNull(): Guild? = supplier.getGuildOrNull(guildId) + + /** + * Requests to get the [Guild] which this rule belongs to. + * + * @throws RequestException if anything went wrong during the request. + * @throws EntityNotFoundException if the [Guild] wasn't found. + */ + public suspend fun getGuild(): Guild = supplier.getGuild(guildId) + /** * Requests to delete this [AutoModerationRule]. * @@ -64,10 +79,10 @@ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleBehavior } -internal infix fun AutoModerationRuleBehavior.autoModerationRuleIsEqualTo(other: Any?) = +internal fun AutoModerationRuleBehavior.autoModerationRuleEquals(other: Any?) = this === other || (other is AutoModerationRuleBehavior && this.id == other.id && this.guildId == other.guildId) -internal fun AutoModerationRuleBehavior.hashAutoModerationRule() = Objects.hash(id, guildId) +internal fun AutoModerationRuleBehavior.autoModerationRuleHashCode() = Objects.hash(id, guildId) /** * Requests to edit this [AutoModerationRule] and returns the edited rule. diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index cf8703ad1f26..1b191e5ba90d 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -96,8 +96,8 @@ public sealed class AutoModerationRule( abstract override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRule - final override fun equals(other: Any?): Boolean = this autoModerationRuleIsEqualTo other - final override fun hashCode(): Int = hashAutoModerationRule() + final override fun equals(other: Any?): Boolean = autoModerationRuleEquals(other) + final override fun hashCode(): Int = autoModerationRuleHashCode() abstract override fun toString(): String } From 08933c512e65bcf66587bd4f8c34267cbf940f6f Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 1 Aug 2022 17:33:37 +0200 Subject: [PATCH 34/57] Let `AutoModerationAction` implement `KordObject` --- .../automoderation/AutoModerationAction.kt | 29 ++++++++++++------- .../automoderation/AutoModerationRule.kt | 2 +- 2 files changed, 20 insertions(+), 11 deletions(-) diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt index a7df9d80d985..54d5d6a849d1 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt @@ -3,6 +3,8 @@ package dev.kord.core.entity.automoderation import dev.kord.common.entity.AutoModerationActionType import dev.kord.common.entity.AutoModerationActionType.* import dev.kord.common.entity.Snowflake +import dev.kord.core.Kord +import dev.kord.core.KordObject import dev.kord.core.cache.data.AutoModerationActionData import dev.kord.core.entity.channel.GuildChannel import kotlin.time.Duration @@ -10,8 +12,9 @@ import kotlin.time.Duration /** An action which will execute whenever an [AutoModerationRule] is triggered. */ public sealed class AutoModerationAction( public val data: AutoModerationActionData, + final override val kord: Kord, expectedActionType: AutoModerationActionType?, -) { +) : KordObject { init { if (expectedActionType == null) { require(data.type is Unknown) { "Expected unknown action type but got ${data.type}" } @@ -24,19 +27,22 @@ public sealed class AutoModerationAction( /** The type of action. */ public abstract val type: AutoModerationActionType + + abstract override fun toString(): String } -internal fun AutoModerationAction(data: AutoModerationActionData) = when (data.type) { - BlockMessage -> BlockMessageAutoModerationAction(data) - SendAlertMessage -> SendAlertMessageAutoModerationAction(data) - Timeout -> TimeoutAutoModerationAction(data) - is Unknown -> UnknownAutoModerationAction(data) +internal fun AutoModerationAction(data: AutoModerationActionData, kord: Kord) = when (data.type) { + BlockMessage -> BlockMessageAutoModerationAction(data, kord) + SendAlertMessage -> SendAlertMessageAutoModerationAction(data, kord) + Timeout -> TimeoutAutoModerationAction(data, kord) + is Unknown -> UnknownAutoModerationAction(data, kord) } /** An [AutoModerationAction] of type [BlockMessage]. */ public class BlockMessageAutoModerationAction( data: AutoModerationActionData, -) : AutoModerationAction(data, expectedActionType = BlockMessage) { + kord: Kord, +) : AutoModerationAction(data, kord, expectedActionType = BlockMessage) { override val type: BlockMessage get() = BlockMessage @@ -46,7 +52,8 @@ public class BlockMessageAutoModerationAction( /** An [AutoModerationAction] of type [SendAlertMessage]. */ public class SendAlertMessageAutoModerationAction( data: AutoModerationActionData, -) : AutoModerationAction(data, expectedActionType = SendAlertMessage) { + kord: Kord, +) : AutoModerationAction(data, kord, expectedActionType = SendAlertMessage) { override val type: SendAlertMessage get() = SendAlertMessage @@ -59,7 +66,8 @@ public class SendAlertMessageAutoModerationAction( /** An [AutoModerationAction] of type [Timeout]. */ public class TimeoutAutoModerationAction( data: AutoModerationActionData, -) : AutoModerationAction(data, expectedActionType = Timeout) { + kord: Kord, +) : AutoModerationAction(data, kord, expectedActionType = Timeout) { override val type: Timeout get() = Timeout @@ -72,7 +80,8 @@ public class TimeoutAutoModerationAction( /** An [AutoModerationAction] of type [Unknown]. */ public class UnknownAutoModerationAction( data: AutoModerationActionData, -) : AutoModerationAction(data, expectedActionType = null) { + kord: Kord, +) : AutoModerationAction(data, kord, expectedActionType = null) { override val type: Unknown get() = data.type as Unknown diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 1b191e5ba90d..e5326397a4b6 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -62,7 +62,7 @@ public sealed class AutoModerationRule( public val eventType: AutoModerationRuleEventType get() = data.eventType /** The actions which will execute when the rule is triggered. */ - public val actions: List get() = data.actions.map { AutoModerationAction(it) } + public val actions: List get() = data.actions.map { AutoModerationAction(it, kord) } /** Whether the rule is enabled. */ public val isEnabled: Boolean get() = data.enabled From b1c0b175dc953f7d2c0423d131e8f9faac8e664e Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 1 Aug 2022 19:52:18 +0200 Subject: [PATCH 35/57] Document `ManageGuild` requirement for `asAutoModerationRule()` --- .../AutoModerationRuleBehavior.kt | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index d0b5f0372a52..2b9ce9b78f8d 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -36,6 +36,8 @@ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { /** * Requests to get this behavior as an [AutoModerationRule]. Returns `null` if it wasn't found. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. */ public suspend fun asAutoModerationRuleOrNull(): AutoModerationRule? = @@ -44,6 +46,8 @@ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { /** * Requests to get this behavior as an [AutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. * @throws EntityNotFoundException if the [AutoModerationRule] wasn't found. */ @@ -116,6 +120,8 @@ public interface KeywordAutoModerationRuleBehavior : TypedAutoModerationRuleBeha * Requests to get this behavior as a [KeywordAutoModerationRule]. * Returns `null` if it wasn't found or if the rule isn't a [KeywordAutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. */ override suspend fun asAutoModerationRuleOrNull(): KeywordAutoModerationRule? = @@ -124,6 +130,8 @@ public interface KeywordAutoModerationRuleBehavior : TypedAutoModerationRuleBeha /** * Requests to get this behavior as a [KeywordAutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. * @throws EntityNotFoundException if the [KeywordAutoModerationRule] wasn't found. * @throws ClassCastException if the rule isn't a [KeywordAutoModerationRule]. @@ -159,6 +167,8 @@ public interface HarmfulLinkAutoModerationRuleBehavior : TypedAutoModerationRule * Requests to get this behavior as a [HarmfulLinkAutoModerationRule]. * Returns `null` if it wasn't found or if the rule isn't a [HarmfulLinkAutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. */ override suspend fun asAutoModerationRuleOrNull(): HarmfulLinkAutoModerationRule? = @@ -167,6 +177,8 @@ public interface HarmfulLinkAutoModerationRuleBehavior : TypedAutoModerationRule /** * Requests to get this behavior as a [HarmfulLinkAutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. * @throws EntityNotFoundException if the [HarmfulLinkAutoModerationRule] wasn't found. * @throws ClassCastException if the rule isn't a [HarmfulLinkAutoModerationRule]. @@ -202,6 +214,8 @@ public interface SpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavio * Requests to get this behavior as a [SpamAutoModerationRule]. * Returns `null` if it wasn't found or if the rule isn't a [SpamAutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. */ override suspend fun asAutoModerationRuleOrNull(): SpamAutoModerationRule? = @@ -210,6 +224,8 @@ public interface SpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavio /** * Requests to get this behavior as a [SpamAutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. * @throws EntityNotFoundException if the [SpamAutoModerationRule] wasn't found. * @throws ClassCastException if the rule isn't a [SpamAutoModerationRule]. @@ -245,6 +261,8 @@ public interface KeywordPresetAutoModerationRuleBehavior : TypedAutoModerationRu * Requests to get this behavior as a [KeywordPresetAutoModerationRule]. * Returns `null` if it wasn't found or if the rule isn't a [KeywordPresetAutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. */ override suspend fun asAutoModerationRuleOrNull(): KeywordPresetAutoModerationRule? = @@ -253,6 +271,8 @@ public interface KeywordPresetAutoModerationRuleBehavior : TypedAutoModerationRu /** * Requests to get this behavior as a [KeywordPresetAutoModerationRule]. * + * This requires the [ManageGuild] permission. + * * @throws RequestException if anything went wrong during the request. * @throws EntityNotFoundException if the [KeywordPresetAutoModerationRule] wasn't found. * @throws ClassCastException if the rule isn't a [KeywordPresetAutoModerationRule]. From 61785a391b68dbe5b9bb902138fdd90e3d175f7f Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 1 Aug 2022 20:10:50 +0200 Subject: [PATCH 36/57] Add convenience functions for keyword matching strategies --- .../AutoModerationRuleBuilder.kt | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index fe275ea43180..94da7db537c1 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -121,6 +121,39 @@ public sealed interface KeywordAutoModerationRuleBuilder : TypedAutoModerationRu } } +/** + * Add a [keyword] with keyword matching strategy + * [Prefix](https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object-keyword-matching-strategies) + * to [keywords][KeywordAutoModerationRuleBuilder.keywords]. + * + * A keyword can be a phrase which contains multiple words. + */ +public fun KeywordAutoModerationRuleBuilder.prefixKeyword(keyword: String) { + keyword("$keyword*") +} + +/** + * Add a [keyword] with keyword matching strategy + * [Suffix](https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object-keyword-matching-strategies) + * to [keywords][KeywordAutoModerationRuleBuilder.keywords]. + * + * A keyword can be a phrase which contains multiple words. + */ +public fun KeywordAutoModerationRuleBuilder.suffixKeyword(keyword: String) { + keyword("*$keyword") +} + +/** + * Add a [keyword] with keyword matching strategy + * [Anywhere](https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object-keyword-matching-strategies) + * to [keywords][KeywordAutoModerationRuleBuilder.keywords]. + * + * A keyword can be a phrase which contains multiple words. + */ +public fun KeywordAutoModerationRuleBuilder.anywhereKeyword(keyword: String) { + keyword("*$keyword*") +} + /** * Add a [Timeout] action which will execute whenever the rule is triggered. * From d5e971c6a1a6dd1f347cebac1a4eb1e3366c8313 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 1 Aug 2022 20:28:41 +0200 Subject: [PATCH 37/57] Change some builder methods to extensions --- .../AutoModerationRuleBuilder.kt | 101 +++++++++--------- 1 file changed, 53 insertions(+), 48 deletions(-) diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index 94da7db537c1..21107e755884 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -48,18 +48,8 @@ public sealed interface AutoModerationRuleBuilder : AuditBuilder { /** The IDs of the roles that should not be affected by the rule. */ public var exemptRoles: MutableList? - /** Exempt a [role][roleId] from being affected by the rule. */ - public fun exemptRole(roleId: Snowflake) { - exemptRoles?.add(roleId) ?: run { exemptRoles = mutableListOf(roleId) } - } - /** The IDs of the channels that should not be affected by the rule. */ public var exemptChannels: MutableList? - - /** Exempt a [channel][channelId] from being affected by the rule. */ - public fun exemptChannel(channelId: Snowflake) { - exemptChannels?.add(channelId) ?: run { exemptChannels = mutableListOf(channelId) } - } } /** Add a [BlockMessage] action which will execute whenever the rule is triggered. */ @@ -85,6 +75,17 @@ public inline fun AutoModerationRuleBuilder.sendAlertMessage( actions?.add(action) ?: assignActions(mutableListOf(action)) } +/** Exempt a [role][roleId] from being affected by the rule. */ +public fun AutoModerationRuleBuilder.exemptRole(roleId: Snowflake) { + exemptRoles?.add(roleId) ?: run { exemptRoles = mutableListOf(roleId) } +} + +/** Exempt a [channel][channelId] from being affected by the rule. */ +public fun AutoModerationRuleBuilder.exemptChannel(channelId: Snowflake) { + exemptChannels?.add(channelId) ?: run { exemptChannels = mutableListOf(channelId) } +} + + @KordDsl public sealed interface TypedAutoModerationRuleBuilder : AutoModerationRuleBuilder { @@ -92,6 +93,7 @@ public sealed interface TypedAutoModerationRuleBuilder : AutoModerationRuleBuild override val triggerType: AutoModerationRuleTriggerType } + @KordDsl public sealed interface KeywordAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { @@ -108,17 +110,33 @@ public sealed interface KeywordAutoModerationRuleBuilder : TypedAutoModerationRu /** Use this to set [keywords][KeywordAutoModerationRuleBuilder.keywords] for [KeywordAutoModerationRuleBuilder]. */ public fun assignKeywords(keywords: MutableList) +} - /** - * Add a [keyword] to [keywords]. - * - * A keyword can be a phrase which contains multiple words. Wildcard symbols can be used to customize how each - * keyword will be matched. See - * [keyword matching strategies](https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object-keyword-matching-strategies). - */ - public fun keyword(keyword: String) { - keywords?.add(keyword) ?: assignKeywords(mutableListOf(keyword)) - } +/** + * Add a [Timeout] action which will execute whenever the rule is triggered. + * + * The [ModerateMembers] permission is required to use this action. + * + * @param duration the timeout duration. + */ +public inline fun KeywordAutoModerationRuleBuilder.timeout( + duration: Duration, + builder: TimeoutAutoModerationActionBuilder.() -> Unit = {}, +) { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val action = TimeoutAutoModerationActionBuilder(duration).apply(builder) + actions?.add(action) ?: assignActions(mutableListOf(action)) +} + +/** + * Add a [keyword] to [keywords][KeywordAutoModerationRuleBuilder.keywords]. + * + * A keyword can be a phrase which contains multiple words. Wildcard symbols can be used to customize how each + * keyword will be matched. See + * [keyword matching strategies](https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object-keyword-matching-strategies). + */ +public fun KeywordAutoModerationRuleBuilder.keyword(keyword: String) { + keywords?.add(keyword) ?: assignKeywords(mutableListOf(keyword)) } /** @@ -154,32 +172,19 @@ public fun KeywordAutoModerationRuleBuilder.anywhereKeyword(keyword: String) { keyword("*$keyword*") } -/** - * Add a [Timeout] action which will execute whenever the rule is triggered. - * - * The [ModerateMembers] permission is required to use this action. - * - * @param duration the timeout duration. - */ -public inline fun KeywordAutoModerationRuleBuilder.timeout( - duration: Duration, - builder: TimeoutAutoModerationActionBuilder.() -> Unit = {}, -) { - contract { callsInPlace(builder, EXACTLY_ONCE) } - val action = TimeoutAutoModerationActionBuilder(duration).apply(builder) - actions?.add(action) ?: assignActions(mutableListOf(action)) -} @KordDsl public sealed interface HarmfulLinkAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { override val triggerType: HarmfulLink get() = HarmfulLink } + @KordDsl public sealed interface SpamAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { override val triggerType: Spam get() = Spam } + @KordDsl public sealed interface KeywordPresetAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { @@ -194,24 +199,24 @@ public sealed interface KeywordPresetAutoModerationRuleBuilder : TypedAutoModera */ public fun assignPresets(presets: MutableList) - /** Add a [preset] to [presets]. */ - public fun preset(preset: AutoModerationRuleKeywordPresetType) { - presets?.add(preset) ?: assignPresets(mutableListOf(preset)) - } - /** * Substrings which will be exempt from triggering the [presets]. * * A keyword can be a phrase which contains multiple words. */ public var allowList: MutableList? +} - /** - * Add a [keyword] to [allowList]. - * - * A keyword can be a phrase which contains multiple words. - */ - public fun allow(keyword: String) { - allowList?.add(keyword) ?: run { allowList = mutableListOf(keyword) } - } +/** Add a [preset] to [presets][KeywordPresetAutoModerationRuleBuilder.presets]. */ +public fun KeywordPresetAutoModerationRuleBuilder.preset(preset: AutoModerationRuleKeywordPresetType) { + presets?.add(preset) ?: assignPresets(mutableListOf(preset)) +} + +/** + * Add a [keyword] to [allowList][KeywordPresetAutoModerationRuleBuilder.allowList]. + * + * A keyword can be a phrase which contains multiple words. + */ +public fun KeywordPresetAutoModerationRuleBuilder.allow(keyword: String) { + allowList?.add(keyword) ?: run { allowList = mutableListOf(keyword) } } From b9f3781714c0cdef773a7d62697307bd0c5ca111 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Wed, 3 Aug 2022 04:45:41 +0200 Subject: [PATCH 38/57] Add core events and Unsafe behavior creating functions --- core/src/main/kotlin/Unsafe.kt | 36 +++-- core/src/main/kotlin/Util.kt | 19 ++- .../AutoModerationRuleBehavior.kt | 146 +++++++++++++++++- .../automoderation/AutoModerationAction.kt | 4 +- .../automoderation/AutoModerationRule.kt | 13 +- core/src/main/kotlin/event/Event.kt | 8 +- .../AutoModerationActionExecutionEvent.kt | 130 ++++++++++++++++ .../automoderation/AutoModerationEvent.kt | 52 +++++++ .../AutoModerationRuleConfigurationEvent.kt | 95 ++++++++++++ .../AutoModerationActionExecutionEventData.kt | 42 +++++ .../kotlin/gateway/DefaultMasterGateway.kt | 9 +- .../handler/AutoModerationEventHandler.kt | 89 +++++++++++ .../handler/BaseGatewayEventHandler.kt | 6 +- .../handler/DefaultGatewayEventInterceptor.kt | 7 +- .../handler/InteractionEventHandler.kt | 3 +- .../gateway/handler/ThreadEventHandler.kt | 14 +- gateway/src/main/kotlin/Command.kt | 6 +- gateway/src/main/kotlin/Gateway.kt | 2 +- .../AutoModerationRuleBuilder.kt | 2 +- 19 files changed, 624 insertions(+), 59 deletions(-) create mode 100644 core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt create mode 100644 core/src/main/kotlin/event/automoderation/AutoModerationEvent.kt create mode 100644 core/src/main/kotlin/event/automoderation/AutoModerationRuleConfigurationEvent.kt create mode 100644 core/src/main/kotlin/event/automoderation/data/AutoModerationActionExecutionEventData.kt create mode 100644 core/src/main/kotlin/gateway/handler/AutoModerationEventHandler.kt diff --git a/core/src/main/kotlin/Unsafe.kt b/core/src/main/kotlin/Unsafe.kt index 5a483169ad8c..79d7b2d12cd0 100644 --- a/core/src/main/kotlin/Unsafe.kt +++ b/core/src/main/kotlin/Unsafe.kt @@ -3,22 +3,9 @@ package dev.kord.core import dev.kord.common.annotation.KordExperimental import dev.kord.common.annotation.KordUnsafe import dev.kord.common.entity.Snowflake -import dev.kord.core.behavior.GlobalApplicationCommandBehavior -import dev.kord.core.behavior.GuildApplicationCommandBehavior -import dev.kord.core.behavior.GuildBehavior -import dev.kord.core.behavior.GuildEmojiBehavior -import dev.kord.core.behavior.GuildScheduledEventBehavior -import dev.kord.core.behavior.MemberBehavior -import dev.kord.core.behavior.MessageBehavior -import dev.kord.core.behavior.RoleBehavior -import dev.kord.core.behavior.StageInstanceBehavior -import dev.kord.core.behavior.ThreadMemberBehavior -import dev.kord.core.behavior.UserBehavior -import dev.kord.core.behavior.WebhookBehavior +import dev.kord.core.behavior.* +import dev.kord.core.behavior.automoderation.* import dev.kord.core.behavior.channel.* -import dev.kord.core.behavior.channel.GuildMessageChannelBehavior -import dev.kord.core.behavior.channel.TopGuildChannelBehavior -import dev.kord.core.behavior.channel.TopGuildMessageChannelBehavior import dev.kord.core.behavior.channel.threads.PrivateThreadParentChannelBehavior import dev.kord.core.behavior.channel.threads.ThreadChannelBehavior import dev.kord.core.behavior.channel.threads.ThreadParentChannelBehavior @@ -41,6 +28,25 @@ import kotlin.DeprecationLevel.ERROR @KordExperimental public class Unsafe(private val kord: Kord) { + public fun autoModerationRule(guildId: Snowflake, ruleId: Snowflake): AutoModerationRuleBehavior = + AutoModerationRuleBehavior(guildId, ruleId, kord) + + public fun keywordAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): KeywordAutoModerationRuleBehavior = + KeywordAutoModerationRuleBehavior(guildId, ruleId, kord) + + public fun harmfulLinkAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + ): HarmfulLinkAutoModerationRuleBehavior = HarmfulLinkAutoModerationRuleBehavior(guildId, ruleId, kord) + + public fun spamAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): SpamAutoModerationRuleBehavior = + SpamAutoModerationRuleBehavior(guildId, ruleId, kord) + + public fun keywordPresetAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + ): KeywordPresetAutoModerationRuleBehavior = KeywordPresetAutoModerationRuleBehavior(guildId, ruleId, kord) + public fun message(channelId: Snowflake, messageId: Snowflake): MessageBehavior = MessageBehavior(channelId = channelId, messageId = messageId, kord = kord) diff --git a/core/src/main/kotlin/Util.kt b/core/src/main/kotlin/Util.kt index dfa5d719da65..2befb992b2ee 100644 --- a/core/src/main/kotlin/Util.kt +++ b/core/src/main/kotlin/Util.kt @@ -6,6 +6,7 @@ import dev.kord.core.entity.KordEntity import dev.kord.core.entity.Message import dev.kord.core.entity.channel.thread.ThreadChannel import dev.kord.core.event.Event +import dev.kord.core.event.automoderation.* import dev.kord.core.event.channel.* import dev.kord.core.event.channel.thread.* import dev.kord.core.event.guild.* @@ -87,7 +88,6 @@ public suspend inline fun Flow.firstOrNull(crossinline predicate: s * The terminal operator that returns `true` if any of the elements match [predicate]. * The flow's collection is cancelled when a match is found. */ -@Suppress("DEPRECATION") @Deprecated( "This is an internal utility function.", ReplaceWith("this.firstOrNull(predicate) != null", "kotlinx.coroutines.flow.firstOrNull"), @@ -455,6 +455,16 @@ public fun Intents.IntentsBuilder.enableEvent(event: KClass): Unit = -> +GuildScheduledEvents + AutoModerationRuleConfigurationEvent::class, + AutoModerationRuleCreateEvent::class, + AutoModerationRuleUpdateEvent::class, + AutoModerationRuleDeleteEvent::class, + -> +AutoModerationConfiguration + + + AutoModerationActionExecutionEvent::class -> +AutoModerationExecution + + /* * events requiring multiple intents: */ @@ -491,6 +501,13 @@ public fun Intents.IntentsBuilder.enableEvent(event: KClass): Unit = +DirectMessageTyping } + AutoModerationEvent::class -> { + // supertype of AutoModerationRuleConfigurationEvent and AutoModerationActionExecutionEvent + // -> requires both auto moderation intents + +AutoModerationConfiguration + +AutoModerationExecution + } + else -> Unit } diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index 2b9ce9b78f8d..0d02a9c0c099 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -5,6 +5,7 @@ import dev.kord.common.entity.AutoModerationRuleTriggerType.* import dev.kord.common.entity.Permission.ManageGuild import dev.kord.common.entity.Snowflake import dev.kord.common.exception.RequestException +import dev.kord.core.Kord import dev.kord.core.behavior.GuildBehavior import dev.kord.core.cache.data.AutoModerationRuleData import dev.kord.core.entity.Guild @@ -12,6 +13,7 @@ import dev.kord.core.entity.KordEntity import dev.kord.core.entity.Strategizable import dev.kord.core.entity.automoderation.* import dev.kord.core.exception.EntityNotFoundException +import dev.kord.core.supplier.EntitySupplier import dev.kord.core.supplier.EntitySupplyStrategy import dev.kord.rest.builder.automoderation.* import dev.kord.rest.request.RestRequestException @@ -19,8 +21,6 @@ import java.util.Objects import kotlin.contracts.InvocationKind.EXACTLY_ONCE import kotlin.contracts.contract -// TODO factory methods, creation from unsafe - /** The behavior of an [AutoModerationRule]. */ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { @@ -81,6 +81,30 @@ public interface AutoModerationRuleBehavior : KordEntity, Strategizable { } override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleBehavior + + override fun equals(other: Any?): Boolean + override fun hashCode(): Int + override fun toString(): String +} + +internal fun AutoModerationRuleBehavior( + guildId: Snowflake, + ruleId: Snowflake, + kord: Kord, + supplier: EntitySupplier = kord.defaultSupplier, +): AutoModerationRuleBehavior = object : AutoModerationRuleBehavior { + override val guildId get() = guildId + override val id get() = ruleId + override val triggerType get() = null + override val kord get() = kord + override val supplier get() = supplier + + override fun withStrategy(strategy: EntitySupplyStrategy<*>) = + AutoModerationRuleBehavior(guildId, ruleId, kord, strategy.supply(kord)) + + override fun equals(other: Any?) = autoModerationRuleEquals(other) + override fun hashCode() = autoModerationRuleHashCode() + override fun toString() = "AutoModerationRuleBehavior(guildId=$guildId, id=$id, kord=$kord, supplier=$supplier)" } internal fun AutoModerationRuleBehavior.autoModerationRuleEquals(other: Any?) = @@ -110,6 +134,20 @@ public interface TypedAutoModerationRuleBehavior : AutoModerationRuleBehavior { override fun withStrategy(strategy: EntitySupplyStrategy<*>): TypedAutoModerationRuleBehavior } +internal fun TypedAutoModerationRuleBehavior( + guildId: Snowflake, + ruleId: Snowflake, + triggerType: AutoModerationRuleTriggerType, + kord: Kord, + supplier: EntitySupplier = kord.defaultSupplier, +): TypedAutoModerationRuleBehavior = when (triggerType) { + Keyword -> KeywordAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) + HarmfulLink -> HarmfulLinkAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) + Spam -> SpamAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) + KeywordPreset -> KeywordPresetAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) + is Unknown -> UnknownAutoModerationRuleBehavior(guildId, ruleId, triggerType, kord, supplier) +} + /** The behavior of a [KeywordAutoModerationRule]. */ public interface KeywordAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { @@ -142,6 +180,26 @@ public interface KeywordAutoModerationRuleBehavior : TypedAutoModerationRuleBeha override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordAutoModerationRuleBehavior } +internal fun KeywordAutoModerationRuleBehavior( + guildId: Snowflake, + ruleId: Snowflake, + kord: Kord, + supplier: EntitySupplier = kord.defaultSupplier, +): KeywordAutoModerationRuleBehavior = object : KeywordAutoModerationRuleBehavior { + override val guildId get() = guildId + override val id get() = ruleId + override val kord get() = kord + override val supplier get() = supplier + + override fun withStrategy(strategy: EntitySupplyStrategy<*>) = + KeywordAutoModerationRuleBehavior(guildId, ruleId, kord, strategy.supply(kord)) + + override fun equals(other: Any?) = autoModerationRuleEquals(other) + override fun hashCode() = autoModerationRuleHashCode() + override fun toString() = + "KeywordAutoModerationRuleBehavior(guildId=$guildId, id=$id, kord=$kord, supplier=$supplier)" +} + /** * Requests to edit this [KeywordAutoModerationRule] and returns the edited rule. * @@ -189,6 +247,26 @@ public interface HarmfulLinkAutoModerationRuleBehavior : TypedAutoModerationRule override fun withStrategy(strategy: EntitySupplyStrategy<*>): HarmfulLinkAutoModerationRuleBehavior } +internal fun HarmfulLinkAutoModerationRuleBehavior( + guildId: Snowflake, + ruleId: Snowflake, + kord: Kord, + supplier: EntitySupplier = kord.defaultSupplier, +): HarmfulLinkAutoModerationRuleBehavior = object : HarmfulLinkAutoModerationRuleBehavior { + override val guildId get() = guildId + override val id get() = ruleId + override val kord get() = kord + override val supplier get() = supplier + + override fun withStrategy(strategy: EntitySupplyStrategy<*>) = + HarmfulLinkAutoModerationRuleBehavior(guildId, ruleId, kord, strategy.supply(kord)) + + override fun equals(other: Any?) = autoModerationRuleEquals(other) + override fun hashCode() = autoModerationRuleHashCode() + override fun toString() = + "HarmfulLinkAutoModerationRuleBehavior(guildId=$guildId, id=$id, kord=$kord, supplier=$supplier)" +} + /** * Requests to edit this [HarmfulLinkAutoModerationRule] and returns the edited rule. * @@ -236,6 +314,26 @@ public interface SpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavio override fun withStrategy(strategy: EntitySupplyStrategy<*>): SpamAutoModerationRuleBehavior } +internal fun SpamAutoModerationRuleBehavior( + guildId: Snowflake, + ruleId: Snowflake, + kord: Kord, + supplier: EntitySupplier = kord.defaultSupplier, +): SpamAutoModerationRuleBehavior = object : SpamAutoModerationRuleBehavior { + override val guildId get() = guildId + override val id get() = ruleId + override val kord get() = kord + override val supplier get() = supplier + + override fun withStrategy(strategy: EntitySupplyStrategy<*>) = + SpamAutoModerationRuleBehavior(guildId, ruleId, kord, strategy.supply(kord)) + + override fun equals(other: Any?) = autoModerationRuleEquals(other) + override fun hashCode() = autoModerationRuleHashCode() + override fun toString() = + "SpamAutoModerationRuleBehavior(guildId=$guildId, id=$id, kord=$kord, supplier=$supplier)" +} + /** * Requests to edit this [SpamAutoModerationRule] and returns the edited rule. * @@ -283,6 +381,26 @@ public interface KeywordPresetAutoModerationRuleBehavior : TypedAutoModerationRu override fun withStrategy(strategy: EntitySupplyStrategy<*>): KeywordPresetAutoModerationRuleBehavior } +internal fun KeywordPresetAutoModerationRuleBehavior( + guildId: Snowflake, + ruleId: Snowflake, + kord: Kord, + supplier: EntitySupplier = kord.defaultSupplier, +): KeywordPresetAutoModerationRuleBehavior = object : KeywordPresetAutoModerationRuleBehavior { + override val guildId get() = guildId + override val id get() = ruleId + override val kord get() = kord + override val supplier get() = supplier + + override fun withStrategy(strategy: EntitySupplyStrategy<*>) = + KeywordPresetAutoModerationRuleBehavior(guildId, ruleId, kord, strategy.supply(kord)) + + override fun equals(other: Any?) = autoModerationRuleEquals(other) + override fun hashCode() = autoModerationRuleHashCode() + override fun toString() = + "KeywordPresetAutoModerationRuleBehavior(guildId=$guildId, id=$id, kord=$kord, supplier=$supplier)" +} + /** * Requests to edit this [KeywordPresetAutoModerationRule] and returns the edited rule. * @@ -297,3 +415,27 @@ public suspend inline fun KeywordPresetAutoModerationRuleBehavior.edit( val rule = kord.rest.autoModeration.modifyKeywordPresetAutoModerationRule(guildId, ruleId = id, builder) return KeywordPresetAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) } + + +@Suppress("FunctionName") +internal fun UnknownAutoModerationRuleBehavior( + guildId: Snowflake, + ruleId: Snowflake, + triggerType: Unknown, + kord: Kord, + supplier: EntitySupplier, +): TypedAutoModerationRuleBehavior = object : TypedAutoModerationRuleBehavior { + override val guildId get() = guildId + override val id get() = ruleId + override val triggerType get() = triggerType + override val kord get() = kord + override val supplier get() = supplier + + override fun withStrategy(strategy: EntitySupplyStrategy<*>) = + UnknownAutoModerationRuleBehavior(guildId, ruleId, triggerType, kord, strategy.supply(kord)) + + override fun equals(other: Any?) = autoModerationRuleEquals(other) + override fun hashCode() = autoModerationRuleHashCode() + override fun toString() = "UnknownAutoModerationRuleBehavior(guildId=$guildId, id=$id, " + + "triggerType=$triggerType, kord=$kord, supplier=$supplier)" +} diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt index 54d5d6a849d1..80898b65c940 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt @@ -6,7 +6,7 @@ import dev.kord.common.entity.Snowflake import dev.kord.core.Kord import dev.kord.core.KordObject import dev.kord.core.cache.data.AutoModerationActionData -import dev.kord.core.entity.channel.GuildChannel +import dev.kord.core.entity.channel.GuildMessageChannel import kotlin.time.Duration /** An action which will execute whenever an [AutoModerationRule] is triggered. */ @@ -57,7 +57,7 @@ public class SendAlertMessageAutoModerationAction( override val type: SendAlertMessage get() = SendAlertMessage - /** The ID of the [GuildChannel] to which user content should be logged. */ + /** The ID of the [GuildMessageChannel] to which user content should be logged. */ public val channelId: Snowflake get() = data.metadata.value!!.channelId.value!! override fun toString(): String = "SendAlertMessageAutoModerationAction(data=$data)" diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index e5326397a4b6..dc3a235b42e7 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -10,12 +10,12 @@ import dev.kord.core.Kord import dev.kord.core.behavior.MemberBehavior import dev.kord.core.behavior.RoleBehavior import dev.kord.core.behavior.automoderation.* -import dev.kord.core.behavior.channel.GuildChannelBehavior +import dev.kord.core.behavior.channel.GuildMessageChannelBehavior import dev.kord.core.cache.data.AutoModerationRuleData import dev.kord.core.entity.Guild import dev.kord.core.entity.Member import dev.kord.core.entity.Role -import dev.kord.core.entity.channel.GuildChannel +import dev.kord.core.entity.channel.GuildMessageChannel import dev.kord.core.supplier.EntitySupplier import dev.kord.core.supplier.EntitySupplyStrategy @@ -73,12 +73,12 @@ public sealed class AutoModerationRule( /** The behaviors of the [Role]s that should not be affected by the rule. */ public val exemptRoles: List get() = data.exemptRoles.map { RoleBehavior(guildId, id = it, kord) } - /** The IDs of the [GuildChannel]s that should not be affected by the rule. */ + /** The IDs of the [GuildMessageChannel]s that should not be affected by the rule. */ public val exemptChannelIds: List get() = data.exemptChannels - /** The behaviors of the [GuildChannel]s that should not be affected by the rule. */ - public val exemptChannels: List - get() = data.exemptChannels.map { GuildChannelBehavior(guildId, id = it, kord) } + /** The behaviors of the [GuildMessageChannel]s that should not be affected by the rule. */ + public val exemptChannels: List + get() = data.exemptChannels.map { GuildMessageChannelBehavior(guildId, id = it, kord) } /** * Returns `this`. @@ -98,7 +98,6 @@ public sealed class AutoModerationRule( final override fun equals(other: Any?): Boolean = autoModerationRuleEquals(other) final override fun hashCode(): Int = autoModerationRuleHashCode() - abstract override fun toString(): String } @PublishedApi diff --git a/core/src/main/kotlin/event/Event.kt b/core/src/main/kotlin/event/Event.kt index 3a6ff37da9c9..b51c5cc1c5c1 100644 --- a/core/src/main/kotlin/event/Event.kt +++ b/core/src/main/kotlin/event/Event.kt @@ -1,25 +1,23 @@ package dev.kord.core.event import dev.kord.core.Kord +import dev.kord.core.KordObject import dev.kord.gateway.Gateway import kotlinx.coroutines.CoroutineScope import kotlinx.coroutines.SupervisorJob import kotlinx.coroutines.job -import kotlin.coroutines.CoroutineContext -public interface Event : CoroutineScope { +public interface Event : KordObject, CoroutineScope { + /** * The Gateway that spawned this event. */ public val gateway: Gateway get() = kord.gateway.gateways.getValue(shard) - public val kord: Kord - /** * The shard number of the [gateway] that spawned this event. */ public val shard: Int - } internal fun kordCoroutineScope(kord: Kord): CoroutineScope = CoroutineScope(kord.coroutineContext + SupervisorJob(kord.coroutineContext.job)) diff --git a/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt b/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt new file mode 100644 index 000000000000..f53f1571c9c8 --- /dev/null +++ b/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt @@ -0,0 +1,130 @@ +package dev.kord.core.event.automoderation + +import dev.kord.common.entity.Permission.ManageGuild +import dev.kord.common.entity.Snowflake +import dev.kord.core.Kord +import dev.kord.core.behavior.MemberBehavior +import dev.kord.core.behavior.MessageBehavior +import dev.kord.core.behavior.automoderation.TypedAutoModerationRuleBehavior +import dev.kord.core.behavior.channel.GuildMessageChannelBehavior +import dev.kord.core.entity.Guild +import dev.kord.core.entity.Member +import dev.kord.core.entity.Message +import dev.kord.core.entity.automoderation.AutoModerationAction +import dev.kord.core.entity.automoderation.AutoModerationRule +import dev.kord.core.entity.automoderation.BlockMessageAutoModerationAction +import dev.kord.core.entity.automoderation.SendAlertMessageAutoModerationAction +import dev.kord.core.entity.channel.GuildMessageChannel +import dev.kord.core.event.automoderation.data.AutoModerationActionExecutionEventData +import dev.kord.core.event.kordCoroutineScope +import dev.kord.core.supplier.EntitySupplier +import dev.kord.core.supplier.EntitySupplyStrategy +import dev.kord.gateway.Intent.MessageContent +import kotlinx.coroutines.CoroutineScope + +/** + * An [AutoModerationEvent] that is sent when an [AutoModerationRule] is triggered and an [AutoModerationAction] is + * executed (e.g. when a message is [blocked][BlockMessageAutoModerationAction]). + * + * This event is only sent to bot users which have the [ManageGuild] permission. + */ +public class AutoModerationActionExecutionEvent( + public val data: AutoModerationActionExecutionEventData, + override val kord: Kord, + override val shard: Int, + override val supplier: EntitySupplier = kord.defaultSupplier, + coroutineScope: CoroutineScope = kordCoroutineScope(kord), +) : AutoModerationEvent, CoroutineScope by coroutineScope { + + /** The ID of the [Guild] in which the [action] was executed. */ + override val guildId: Snowflake get() = data.guildId + + /** The [AutoModerationAction] which was executed. */ + public val action: AutoModerationAction get() = AutoModerationAction(data.action, kord) + + /** The ID of the [AutoModerationRule] which the [action] belongs to. */ + override val ruleId: Snowflake get() = data.ruleId + + /** The behavior of the [AutoModerationRule] which the [action] belongs to. */ + override val rule: TypedAutoModerationRuleBehavior + get() = TypedAutoModerationRuleBehavior(guildId, ruleId, data.ruleTriggerType, kord) + + /** The ID of the [Member] which generated the content which triggered the rule. */ + public val userId: Snowflake get() = data.userId + + /** The behavior of the [Member] which generated the content which triggered the rule. */ + public val user: MemberBehavior get() = MemberBehavior(guildId, id = userId, kord) + + /** The ID of the [GuildMessageChannel] in which user [content] was posted. */ + public val channelId: Snowflake? get() = data.channelId.value + + /** The behavior of the [GuildMessageChannel] in which user [content] was posted. */ + public val channel: GuildMessageChannelBehavior? + get() = channelId?.let { GuildMessageChannelBehavior(guildId, id = it, kord) } + + /** + * The ID of any user [Message] which [content] belongs to. + * + * This will be `null` if the message was [blocked][BlockMessageAutoModerationAction] by Auto Moderation or + * [content] was not part of any message. + */ + public val messageId: Snowflake? get() = data.messageId.value + + /** + * The behavior of any user [Message] which [content] belongs to. + * + * This will be `null` if the message was [blocked][BlockMessageAutoModerationAction] by Auto Moderation or + * [content] was not part of any message. + */ + public val message: MessageBehavior? + get() { + return MessageBehavior(channelId ?: return null, messageId ?: return null, kord) + } + + /** + * The ID of any system Auto Moderation [Message] posted as a result of the [action]. + * + * This will be `null` if the [action] is not of type [SendAlertMessageAutoModerationAction]. + */ + public val alertSystemMessageId: Snowflake? get() = data.alertSystemMessageId.value + + /** + * The behavior of any system Auto Moderation [Message] posted as a result of the [action]. + * + * This will be `null` if the [action] is not of type [SendAlertMessageAutoModerationAction]. + */ + public val alertSystemMessage: MessageBehavior? + get() { + val channelId = (action as? SendAlertMessageAutoModerationAction)?.channelId ?: return null + return MessageBehavior(channelId, alertSystemMessageId ?: return null, kord) + } + + /** + * The user generated text content. + * + * The [MessageContent] intent is required to receive non-empty values. + */ + public val content: String get() = data.content + + /** + * The word or phrase configured in the [rule] that triggered it. + * + * This might be `null` if the [rule] was triggered for another reason. + */ + public val matchedKeyword: String? get() = data.matchedKeyword + + /** + * The substring in [content] that triggered the rule. + * + * This might be `null` for the same reasons as [matchedKeyword]. + * + * The [MessageContent] intent is required to receive non-empty values. + */ + public val matchedContent: String? get() = data.matchedContent + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationActionExecutionEvent = + AutoModerationActionExecutionEvent(data, kord, shard, strategy.supply(kord)) + + override fun toString(): String = + "AutoModerationActionExecutionEvent(data=$data, kord=$kord, shard=$shard, supplier=$supplier)" +} diff --git a/core/src/main/kotlin/event/automoderation/AutoModerationEvent.kt b/core/src/main/kotlin/event/automoderation/AutoModerationEvent.kt new file mode 100644 index 000000000000..1c5ab9909446 --- /dev/null +++ b/core/src/main/kotlin/event/automoderation/AutoModerationEvent.kt @@ -0,0 +1,52 @@ +package dev.kord.core.event.automoderation + +import dev.kord.common.entity.Permission.ManageGuild +import dev.kord.common.entity.Snowflake +import dev.kord.common.exception.RequestException +import dev.kord.core.behavior.GuildBehavior +import dev.kord.core.behavior.automoderation.TypedAutoModerationRuleBehavior +import dev.kord.core.entity.Guild +import dev.kord.core.entity.Strategizable +import dev.kord.core.entity.automoderation.AutoModerationRule +import dev.kord.core.event.Event +import dev.kord.core.exception.EntityNotFoundException +import dev.kord.core.supplier.EntitySupplyStrategy + +/** + * An [Event] that is associated with an [AutoModerationRule]. + * + * Events of this type are only sent to bot users which have the [ManageGuild] permission. + */ +public sealed interface AutoModerationEvent : Event, Strategizable { + + /** The ID of the [AutoModerationRule] this event is associated with. */ + public val ruleId: Snowflake + + /** The behavior of the [AutoModerationRule] this event is associated with. */ + public val rule: TypedAutoModerationRuleBehavior + + /** The ID of the [Guild] this event is for. */ + public val guildId: Snowflake + + /** The behavior of the [Guild] this event is for. */ + public val guild: GuildBehavior get() = GuildBehavior(guildId, kord) + + /** + * Requests to get the [Guild] this event is for. Returns `null` if it wasn't found. + * + * @throws RequestException if anything went wrong during the request. + */ + public suspend fun getGuildOrNull(): Guild? = supplier.getGuildOrNull(guildId) + + /** + * Requests to get the [Guild] this event is for. + * + * @throws RequestException if anything went wrong during the request. + * @throws EntityNotFoundException if the [Guild] wasn't found. + */ + public suspend fun getGuild(): Guild = supplier.getGuild(guildId) + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationEvent + + override fun toString(): String +} diff --git a/core/src/main/kotlin/event/automoderation/AutoModerationRuleConfigurationEvent.kt b/core/src/main/kotlin/event/automoderation/AutoModerationRuleConfigurationEvent.kt new file mode 100644 index 000000000000..df38b777b601 --- /dev/null +++ b/core/src/main/kotlin/event/automoderation/AutoModerationRuleConfigurationEvent.kt @@ -0,0 +1,95 @@ +package dev.kord.core.event.automoderation + +import dev.kord.common.entity.Permission.ManageGuild +import dev.kord.common.entity.Snowflake +import dev.kord.core.Kord +import dev.kord.core.entity.automoderation.AutoModerationRule +import dev.kord.core.event.kordCoroutineScope +import dev.kord.core.supplier.EntitySupplier +import dev.kord.core.supplier.EntitySupplyStrategy +import kotlinx.coroutines.CoroutineScope + +/** + * An [AutoModerationEvent] that is sent when an [AutoModerationRule] is configured (i.e. + * [created][AutoModerationRuleCreateEvent], [updated][AutoModerationRuleUpdateEvent] or + * [deleted][AutoModerationRuleDeleteEvent]). + * + * Events of this type are only sent to bot users which have the [ManageGuild] permission. + */ +public sealed interface AutoModerationRuleConfigurationEvent : AutoModerationEvent { + + /** The ID of the [rule]. */ + override val ruleId: Snowflake get() = rule.id + + /** The [AutoModerationRule] that was configured. */ + override val rule: AutoModerationRule + + override val guildId: Snowflake get() = rule.guildId + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleConfigurationEvent +} + +/** + * An [AutoModerationRuleConfigurationEvent] that is sent when an [AutoModerationRule] is created. + * + * This event is only sent to bot users which have the [ManageGuild] permission. + */ +public class AutoModerationRuleCreateEvent( + /** The [AutoModerationRule] that was created. */ + override val rule: AutoModerationRule, + override val kord: Kord, + override val shard: Int, + override val supplier: EntitySupplier = kord.defaultSupplier, + coroutineScope: CoroutineScope = kordCoroutineScope(kord), +) : AutoModerationRuleConfigurationEvent, CoroutineScope by coroutineScope { + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleCreateEvent = + AutoModerationRuleCreateEvent(rule, kord, shard, strategy.supply(kord)) + + override fun toString(): String = + "AutoModerationRuleCreateEvent(rule=$rule, kord=$kord, shard=$shard, supplier=$supplier)" +} + +/** + * An [AutoModerationRuleConfigurationEvent] that is sent when an [AutoModerationRule] is updated. + * + * This event is only sent to bot users which have the [ManageGuild] permission. + */ +public class AutoModerationRuleUpdateEvent( + /** The [AutoModerationRule] that was updated. */ + override val rule: AutoModerationRule, + /** The [rule] as found in [cache][Kord.cache] before the update. */ + public val old: AutoModerationRule?, + override val kord: Kord, + override val shard: Int, + override val supplier: EntitySupplier = kord.defaultSupplier, + coroutineScope: CoroutineScope = kordCoroutineScope(kord), +) : AutoModerationRuleConfigurationEvent, CoroutineScope by coroutineScope { + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleUpdateEvent = + AutoModerationRuleUpdateEvent(rule, old, kord, shard, strategy.supply(kord)) + + override fun toString(): String = + "AutoModerationRuleUpdateEvent(rule=$rule, old=$old, kord=$kord, shard=$shard, supplier=$supplier)" +} + +/** + * An [AutoModerationRuleConfigurationEvent] that is sent when an [AutoModerationRule] is deleted. + * + * This event is only sent to bot users which have the [ManageGuild] permission. + */ +public class AutoModerationRuleDeleteEvent( + /** The [AutoModerationRule] that was deleted. */ + override val rule: AutoModerationRule, + override val kord: Kord, + override val shard: Int, + override val supplier: EntitySupplier = kord.defaultSupplier, + coroutineScope: CoroutineScope = kordCoroutineScope(kord), +) : AutoModerationRuleConfigurationEvent, CoroutineScope by coroutineScope { + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleDeleteEvent = + AutoModerationRuleDeleteEvent(rule, kord, shard, strategy.supply(kord)) + + override fun toString(): String = + "AutoModerationRuleDeleteEvent(rule=$rule, kord=$kord, shard=$shard, supplier=$supplier)" +} diff --git a/core/src/main/kotlin/event/automoderation/data/AutoModerationActionExecutionEventData.kt b/core/src/main/kotlin/event/automoderation/data/AutoModerationActionExecutionEventData.kt new file mode 100644 index 000000000000..a5f50c4a9cbb --- /dev/null +++ b/core/src/main/kotlin/event/automoderation/data/AutoModerationActionExecutionEventData.kt @@ -0,0 +1,42 @@ +package dev.kord.core.event.automoderation.data + +import dev.kord.common.entity.AutoModerationRuleTriggerType +import dev.kord.common.entity.Snowflake +import dev.kord.common.entity.optional.OptionalSnowflake +import dev.kord.core.cache.data.AutoModerationActionData +import dev.kord.gateway.DiscordAutoModerationActionExecution +import kotlinx.serialization.Serializable + +@Serializable +public data class AutoModerationActionExecutionEventData( + val guildId: Snowflake, + val action: AutoModerationActionData, + val ruleId: Snowflake, + val ruleTriggerType: AutoModerationRuleTriggerType, + val userId: Snowflake, + val channelId: OptionalSnowflake = OptionalSnowflake.Missing, + val messageId: OptionalSnowflake = OptionalSnowflake.Missing, + val alertSystemMessageId: OptionalSnowflake = OptionalSnowflake.Missing, + val content: String, + val matchedKeyword: String?, + val matchedContent: String?, +) { + public companion object { + public fun from(entity: DiscordAutoModerationActionExecution): AutoModerationActionExecutionEventData = + with(entity) { + AutoModerationActionExecutionEventData( + guildId = guildId, + action = AutoModerationActionData.from(action), + ruleId = ruleId, + ruleTriggerType = ruleTriggerType, + userId = userId, + channelId = channelId, + messageId = messageId, + alertSystemMessageId = alertSystemMessageId, + content = content, + matchedKeyword = matchedKeyword, + matchedContent = matchedContent, + ) + } + } +} diff --git a/core/src/main/kotlin/gateway/DefaultMasterGateway.kt b/core/src/main/kotlin/gateway/DefaultMasterGateway.kt index e6e670ed64e2..411c85afcb28 100644 --- a/core/src/main/kotlin/gateway/DefaultMasterGateway.kt +++ b/core/src/main/kotlin/gateway/DefaultMasterGateway.kt @@ -1,11 +1,9 @@ package dev.kord.core.gateway import dev.kord.gateway.Gateway -import kotlinx.coroutines.FlowPreview import kotlinx.coroutines.flow.Flow -import kotlinx.coroutines.flow.asFlow -import kotlinx.coroutines.flow.flattenMerge import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.merge import kotlin.time.Duration import kotlin.time.Duration.Companion.microseconds @@ -28,10 +26,9 @@ public class DefaultMasterGateway( } - @OptIn(FlowPreview::class) - override val events: Flow = gateways.entries.asFlow() + override val events: Flow = gateways.entries .map { (shard, gateway) -> gateway.events.map { ShardEvent(it, gateway, shard) } } - .flattenMerge(gateways.size.coerceAtLeast(1)) + .merge() override fun toString(): String { diff --git a/core/src/main/kotlin/gateway/handler/AutoModerationEventHandler.kt b/core/src/main/kotlin/gateway/handler/AutoModerationEventHandler.kt new file mode 100644 index 000000000000..e9162092e571 --- /dev/null +++ b/core/src/main/kotlin/gateway/handler/AutoModerationEventHandler.kt @@ -0,0 +1,89 @@ +package dev.kord.core.gateway.handler + +import dev.kord.cache.api.DataCache +import dev.kord.cache.api.put +import dev.kord.cache.api.query +import dev.kord.cache.api.remove +import dev.kord.core.Kord +import dev.kord.core.cache.data.AutoModerationRuleData +import dev.kord.core.cache.idEq +import dev.kord.core.entity.automoderation.AutoModerationRule +import dev.kord.core.event.automoderation.* +import dev.kord.core.event.automoderation.data.AutoModerationActionExecutionEventData +import dev.kord.gateway.* +import kotlinx.coroutines.CoroutineScope + +internal class AutoModerationEventHandler(cache: DataCache) : BaseGatewayEventHandler(cache) { + + override suspend fun handle( + event: Event, + shard: Int, + kord: Kord, + coroutineScope: CoroutineScope, + ): AutoModerationEvent? = when (event) { + is AutoModerationRuleCreate -> handleRuleCreate(event, shard, kord, coroutineScope) + is AutoModerationRuleUpdate -> handleRuleUpdate(event, shard, kord, coroutineScope) + is AutoModerationRuleDelete -> handleRuleDelete(event, shard, kord, coroutineScope) + is AutoModerationActionExecution -> AutoModerationActionExecutionEvent( + data = AutoModerationActionExecutionEventData.from(event.actionExecution), + kord = kord, + shard = shard, + coroutineScope = coroutineScope, + ) + else -> null + } + + + private suspend fun handleRuleCreate( + event: AutoModerationRuleCreate, + shard: Int, + kord: Kord, + coroutineScope: CoroutineScope, + ): AutoModerationRuleCreateEvent { + val data = AutoModerationRuleData.from(event.rule) + cache.put(data) + + val rule = AutoModerationRule(data, kord) + return AutoModerationRuleCreateEvent(rule = rule, kord = kord, shard = shard, coroutineScope = coroutineScope) + } + + private suspend fun handleRuleUpdate( + event: AutoModerationRuleUpdate, + shard: Int, + kord: Kord, + coroutineScope: CoroutineScope, + ): AutoModerationRuleUpdateEvent { + val data = AutoModerationRuleData.from(event.rule) + val oldData = cache.query { + idEq(AutoModerationRuleData::id, data.id) + idEq(AutoModerationRuleData::guildId, data.guildId) + }.singleOrNull() + cache.put(data) + + val rule = AutoModerationRule(data, kord) + val old = oldData?.let { AutoModerationRule(it, kord) } + return AutoModerationRuleUpdateEvent( + rule = rule, + old = old, + kord = kord, + shard = shard, + coroutineScope = coroutineScope, + ) + } + + private suspend fun handleRuleDelete( + event: AutoModerationRuleDelete, + shard: Int, + kord: Kord, + coroutineScope: CoroutineScope, + ): AutoModerationRuleDeleteEvent { + val data = AutoModerationRuleData.from(event.rule) + cache.remove { + idEq(AutoModerationRuleData::id, data.id) + idEq(AutoModerationRuleData::guildId, data.guildId) + } + + val rule = AutoModerationRule(data, kord) + return AutoModerationRuleDeleteEvent(rule = rule, kord = kord, shard = shard, coroutineScope = coroutineScope) + } +} diff --git a/core/src/main/kotlin/gateway/handler/BaseGatewayEventHandler.kt b/core/src/main/kotlin/gateway/handler/BaseGatewayEventHandler.kt index 9f21bf1aa8a1..0584e337149f 100644 --- a/core/src/main/kotlin/gateway/handler/BaseGatewayEventHandler.kt +++ b/core/src/main/kotlin/gateway/handler/BaseGatewayEventHandler.kt @@ -3,14 +3,12 @@ package dev.kord.core.gateway.handler import dev.kord.cache.api.DataCache import dev.kord.core.Kord import kotlinx.coroutines.CoroutineScope -import kotlin.coroutines.CoroutineContext import dev.kord.core.event.Event as CoreEvent import dev.kord.gateway.Event as GatewayEvent -public abstract class BaseGatewayEventHandler( +internal abstract class BaseGatewayEventHandler( protected val cache: DataCache ) { - public abstract suspend fun handle(event: GatewayEvent, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? - + abstract suspend fun handle(event: GatewayEvent, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? } diff --git a/core/src/main/kotlin/gateway/handler/DefaultGatewayEventInterceptor.kt b/core/src/main/kotlin/gateway/handler/DefaultGatewayEventInterceptor.kt index 521b5ec19305..26464f0f9bb7 100644 --- a/core/src/main/kotlin/gateway/handler/DefaultGatewayEventInterceptor.kt +++ b/core/src/main/kotlin/gateway/handler/DefaultGatewayEventInterceptor.kt @@ -17,15 +17,16 @@ public class DefaultGatewayEventInterceptor( ) : GatewayEventInterceptor { private val listeners = listOf( - MessageEventHandler(cache), + AutoModerationEventHandler(cache), ChannelEventHandler(cache), - ThreadEventHandler(cache), GuildEventHandler(cache), + InteractionEventHandler(cache), LifeCycleEventHandler(cache), + MessageEventHandler(cache), + ThreadEventHandler(cache), UserEventHandler(cache), VoiceEventHandler(cache), WebhookEventHandler(cache), - InteractionEventHandler(cache) ) override suspend fun handle(event: ShardEvent, kord: Kord): CoreEvent? { diff --git a/core/src/main/kotlin/gateway/handler/InteractionEventHandler.kt b/core/src/main/kotlin/gateway/handler/InteractionEventHandler.kt index 3c09a24016a6..d547375602ea 100644 --- a/core/src/main/kotlin/gateway/handler/InteractionEventHandler.kt +++ b/core/src/main/kotlin/gateway/handler/InteractionEventHandler.kt @@ -5,7 +5,6 @@ import dev.kord.cache.api.put import dev.kord.cache.api.remove import dev.kord.core.Kord import dev.kord.core.cache.data.ApplicationCommandData -import dev.kord.core.cache.data.GuildApplicationCommandPermissionData import dev.kord.core.cache.data.GuildApplicationCommandPermissionsData import dev.kord.core.cache.data.InteractionData import dev.kord.core.cache.idEq @@ -17,7 +16,7 @@ import kotlinx.coroutines.CoroutineScope import dev.kord.core.event.Event as CoreEvent -public class InteractionEventHandler( +internal class InteractionEventHandler( cache: DataCache ) : BaseGatewayEventHandler(cache) { diff --git a/core/src/main/kotlin/gateway/handler/ThreadEventHandler.kt b/core/src/main/kotlin/gateway/handler/ThreadEventHandler.kt index 9c93815022ca..2f4d8893c9be 100644 --- a/core/src/main/kotlin/gateway/handler/ThreadEventHandler.kt +++ b/core/src/main/kotlin/gateway/handler/ThreadEventHandler.kt @@ -16,7 +16,7 @@ import dev.kord.gateway.* import kotlinx.coroutines.CoroutineScope import dev.kord.core.event.Event as CoreEvent -public class ThreadEventHandler( +internal class ThreadEventHandler( cache: DataCache ) : BaseGatewayEventHandler(cache) { @@ -35,7 +35,7 @@ public class ThreadEventHandler( else -> null } - public suspend fun handle(event: ThreadCreate, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? { + private suspend fun handle(event: ThreadCreate, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? { val channelData = event.channel.toData() cache.put(channelData) @@ -48,7 +48,7 @@ public class ThreadEventHandler( return coreEvent } - public suspend fun handle(event: ThreadUpdate, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? { + private suspend fun handle(event: ThreadUpdate, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? { val channelData = event.channel.toData() val oldData = cache.query { idEq(ChannelData::id, event.channel.id) @@ -69,7 +69,7 @@ public class ThreadEventHandler( } - public suspend fun handle(event: ThreadDelete, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? { + private suspend fun handle(event: ThreadDelete, shard: Int, kord: Kord, coroutineScope: CoroutineScope): ThreadChannelDeleteEvent { val channelData = event.channel.toData() val cachedData = cache.query { idEq(ChannelData::id, channelData.id) }.singleOrNull() @@ -92,7 +92,7 @@ public class ThreadEventHandler( return coreEvent } - public suspend fun handle(event: ThreadListSync, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? { + private suspend fun handle(event: ThreadListSync, shard: Int, kord: Kord, coroutineScope: CoroutineScope): ThreadListSyncEvent { val data = ThreadListSyncData.from(event) data.threads.forEach { thread -> @@ -105,13 +105,13 @@ public class ThreadEventHandler( return ThreadListSyncEvent(data, kord, shard, coroutineScope = coroutineScope) } - public fun handle(event: ThreadMemberUpdate, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? { + private fun handle(event: ThreadMemberUpdate, shard: Int, kord: Kord, coroutineScope: CoroutineScope): ThreadMemberUpdateEvent { val data = ThreadMemberData.from(event.member) val member = ThreadMember(data, kord) return ThreadMemberUpdateEvent(member, kord, shard, coroutineScope) } - public suspend fun handle(event: ThreadMembersUpdate, shard: Int, kord: Kord, coroutineScope: CoroutineScope): CoreEvent? { + private suspend fun handle(event: ThreadMembersUpdate, shard: Int, kord: Kord, coroutineScope: CoroutineScope): ThreadMembersUpdateEvent { val data = ThreadMembersUpdateEventData.from(event) for (removedMemberId in data.removedMemberIds.orEmpty()) { cache.remove { diff --git a/gateway/src/main/kotlin/Command.kt b/gateway/src/main/kotlin/Command.kt index aab9b7a8f9ff..0ab1b88bf8ab 100644 --- a/gateway/src/main/kotlin/Command.kt +++ b/gateway/src/main/kotlin/Command.kt @@ -90,8 +90,8 @@ internal data class Identify( val intents: Intents, ) : Command() { override fun toString(): String = - "Identify(token=hunter2,properties=$properties,compress=$compress,largeThreshold=$largeThreshold," + - "shard=$shard,presence=$presence" + "Identify(token=hunter2, properties=$properties, compress=$compress, largeThreshold=$largeThreshold, " + + "shard=$shard, presence=$presence, intents=$intents)" } @Serializable @@ -133,7 +133,7 @@ internal data class Resume( @SerialName("seq") val sequenceNumber: Int, ) : Command() { - override fun toString(): String = "Resume(token=hunter2,sessionId=$sessionId,sequenceNumber:$sequenceNumber)" + override fun toString(): String = "Resume(token=hunter2, sessionId=$sessionId, sequenceNumber=$sequenceNumber)" } /** diff --git a/gateway/src/main/kotlin/Gateway.kt b/gateway/src/main/kotlin/Gateway.kt index 3768113c0140..dcafb555a4c1 100644 --- a/gateway/src/main/kotlin/Gateway.kt +++ b/gateway/src/main/kotlin/Gateway.kt @@ -32,7 +32,7 @@ public interface Gateway : CoroutineScope { public val events: SharedFlow /** - * The duration between the last [Heartbeat] and [HeartbeatACK]. + * The duration between the last [Heartbeat][Command.Heartbeat] and [HeartbeatACK]. * * This flow will have a [value][StateFlow.value] of `null` if the gateway is not * [active][Gateway.start], or no [HeartbeatACK] has been received yet. diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index 21107e755884..2460704bb268 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -31,7 +31,7 @@ public sealed interface AutoModerationRuleBuilder : AuditBuilder { /** * The rule [trigger type][AutoModerationRuleTriggerType]. * - * This might be `null`, if the function that created this builder doesn't know the trigger type based on the + * This might be `null` if the function that created this builder doesn't know the trigger type based on the * type system. */ public val triggerType: AutoModerationRuleTriggerType? From bd864b6923c6530fa72feea1783f8ddb7f1b176c Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 7 Aug 2022 14:48:38 +0200 Subject: [PATCH 39/57] Register `AutoModerationRuleData` for caching --- core/src/main/kotlin/cache/DataCacheExtensions.kt | 3 ++- core/src/main/kotlin/cache/data/AutoModeration.kt | 5 +++++ core/src/main/kotlin/cache/data/GuildData.kt | 1 + core/src/main/kotlin/cache/data/UserData.kt | 13 ++++++------- 4 files changed, 14 insertions(+), 8 deletions(-) diff --git a/core/src/main/kotlin/cache/DataCacheExtensions.kt b/core/src/main/kotlin/cache/DataCacheExtensions.kt index 7fb7a8403f14..94abbf81e5c6 100644 --- a/core/src/main/kotlin/cache/DataCacheExtensions.kt +++ b/core/src/main/kotlin/cache/DataCacheExtensions.kt @@ -23,7 +23,7 @@ internal suspend fun DataCache.registerKordData() = register( GuildApplicationCommandPermissionsData.description, StickerPackData.description, StickerData.description, - + AutoModerationRuleData.description, ) /** @@ -40,6 +40,7 @@ internal suspend fun DataCache.removeKordData() { query().remove() query().remove() query().remove() + query().remove() } /** diff --git a/core/src/main/kotlin/cache/data/AutoModeration.kt b/core/src/main/kotlin/cache/data/AutoModeration.kt index 32fb3dd74cc7..c748268e5709 100644 --- a/core/src/main/kotlin/cache/data/AutoModeration.kt +++ b/core/src/main/kotlin/cache/data/AutoModeration.kt @@ -1,5 +1,7 @@ package dev.kord.core.cache.data +import dev.kord.cache.api.data.DataDescription +import dev.kord.cache.api.data.description import dev.kord.common.entity.* import dev.kord.common.entity.optional.Optional import dev.kord.common.entity.optional.OptionalSnowflake @@ -22,6 +24,9 @@ public data class AutoModerationRuleData( val exemptChannels: List, ) { public companion object { + public val description: DataDescription = + description(AutoModerationRuleData::id) + public fun from(rule: DiscordAutoModerationRule): AutoModerationRuleData = with(rule) { AutoModerationRuleData( id = id, diff --git a/core/src/main/kotlin/cache/data/GuildData.kt b/core/src/main/kotlin/cache/data/GuildData.kt index a9c71d2e8ccb..6377ba17b00b 100644 --- a/core/src/main/kotlin/cache/data/GuildData.kt +++ b/core/src/main/kotlin/cache/data/GuildData.kt @@ -77,6 +77,7 @@ public data class GuildData( link(GuildData::id to WebhookData::nullableGuildId) link(GuildData::id to VoiceStateData::guildId) link(GuildData::id to PresenceData::guildId) + link(GuildData::id to AutoModerationRuleData::guildId) } public fun from(entity: DiscordGuild): GuildData = with(entity) { diff --git a/core/src/main/kotlin/cache/data/UserData.kt b/core/src/main/kotlin/cache/data/UserData.kt index ae10353dbe4e..d211f92894ee 100644 --- a/core/src/main/kotlin/cache/data/UserData.kt +++ b/core/src/main/kotlin/cache/data/UserData.kt @@ -26,13 +26,12 @@ public data class UserData( ) { public companion object { - public val description: DataDescription - get() = description(UserData::id) { - link(UserData::id to MemberData::userId) - link(UserData::id to WebhookData::nullableUserId) - link(UserData::id to VoiceStateData::userId) - link(UserData::id to PresenceData::userId) - } + public val description: DataDescription = description(UserData::id) { + link(UserData::id to MemberData::userId) + link(UserData::id to WebhookData::nullableUserId) + link(UserData::id to VoiceStateData::userId) + link(UserData::id to PresenceData::userId) + } public fun from(entity: DiscordUser): UserData = with(entity) { UserData(id, username, discriminator, avatar, bot, publicFlags, banner, accentColor) From 6cebbce0ca6e1ee7e5aa5238b6ccc8e3d598aa6d Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 7 Aug 2022 21:41:56 +0200 Subject: [PATCH 40/57] Add `MessageContent` intent to `AutoModerationActionExecutionEvent` in `enableEvent` --- core/src/main/kotlin/Util.kt | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-) diff --git a/core/src/main/kotlin/Util.kt b/core/src/main/kotlin/Util.kt index 2befb992b2ee..094205af1e4d 100644 --- a/core/src/main/kotlin/Util.kt +++ b/core/src/main/kotlin/Util.kt @@ -462,9 +462,6 @@ public fun Intents.IntentsBuilder.enableEvent(event: KClass): Unit = -> +AutoModerationConfiguration - AutoModerationActionExecutionEvent::class -> +AutoModerationExecution - - /* * events requiring multiple intents: */ @@ -501,11 +498,17 @@ public fun Intents.IntentsBuilder.enableEvent(event: KClass): Unit = +DirectMessageTyping } + AutoModerationActionExecutionEvent::class -> { + +AutoModerationExecution + +MessageContent + } + AutoModerationEvent::class -> { // supertype of AutoModerationRuleConfigurationEvent and AutoModerationActionExecutionEvent - // -> requires both auto moderation intents + // -> requires intents for both +AutoModerationConfiguration +AutoModerationExecution + +MessageContent } From 624d93b7d13d0cac8d177cd6304cc6defe0c6106 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 7 Aug 2022 21:44:09 +0200 Subject: [PATCH 41/57] Add `autoModerationRules` to `AuditLog` --- core/src/main/kotlin/entity/AuditLog.kt | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/core/src/main/kotlin/entity/AuditLog.kt b/core/src/main/kotlin/entity/AuditLog.kt index f6f1ac7fd504..10737c742af7 100644 --- a/core/src/main/kotlin/entity/AuditLog.kt +++ b/core/src/main/kotlin/entity/AuditLog.kt @@ -4,10 +4,11 @@ import dev.kord.common.entity.* import dev.kord.common.entity.optional.orEmpty import dev.kord.core.Kord import dev.kord.core.KordObject +import dev.kord.core.cache.data.AutoModerationRuleData import dev.kord.core.cache.data.ChannelData -import dev.kord.core.cache.data.IntegrationData import dev.kord.core.cache.data.UserData import dev.kord.core.cache.data.WebhookData +import dev.kord.core.entity.automoderation.AutoModerationRule import dev.kord.core.entity.channel.Channel import dev.kord.core.entity.channel.thread.ThreadChannel @@ -23,10 +24,14 @@ public class AuditLog( public val integrations: List get() = data.integrations.map { it.id } - public val threads: List get() = data.threads.map { - val data = ChannelData.from(it) - Channel.from(data, kord) - }.filterIsInstance() + public val threads: List + get() = data.threads.map { + val data = ChannelData.from(it) + Channel.from(data, kord) + }.filterIsInstance() + + public val autoModerationRules: List + get() = data.autoModerationRules.map { AutoModerationRule(AutoModerationRuleData.from(it), kord) } public val entries: List get() = data.auditLogEntries.map { AuditLogEntry(it, kord) } From 310deee2f50940bf93d0594bf559b0df816cf197 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 7 Aug 2022 23:07:02 +0200 Subject: [PATCH 42/57] Rename `allowList` to `allowedKeywords` --- .../entity/automoderation/AutoModerationRule.kt | 2 +- .../automoderation/AutoModerationRuleBuilder.kt | 8 ++++---- .../AutoModerationRuleCreateBuilder.kt | 6 +++--- .../AutoModerationRuleModifyBuilder.kt | 15 ++++++++------- 4 files changed, 16 insertions(+), 15 deletions(-) diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index dc3a235b42e7..d9bd9b6145ef 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -177,7 +177,7 @@ public class KeywordPresetAutoModerationRule(data: AutoModerationRuleData, kord: * * A keyword can be a phrase which contains multiple words. */ - public val allowList: List get() = data.triggerMetadata.allowList.orEmpty() + public val allowedKeywords: List get() = data.triggerMetadata.allowList.orEmpty() override suspend fun asAutoModerationRuleOrNull(): KeywordPresetAutoModerationRule = this override suspend fun asAutoModerationRule(): KeywordPresetAutoModerationRule = this diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index 2460704bb268..15276901141e 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -204,7 +204,7 @@ public sealed interface KeywordPresetAutoModerationRuleBuilder : TypedAutoModera * * A keyword can be a phrase which contains multiple words. */ - public var allowList: MutableList? + public var allowedKeywords: MutableList? } /** Add a [preset] to [presets][KeywordPresetAutoModerationRuleBuilder.presets]. */ @@ -213,10 +213,10 @@ public fun KeywordPresetAutoModerationRuleBuilder.preset(preset: AutoModerationR } /** - * Add a [keyword] to [allowList][KeywordPresetAutoModerationRuleBuilder.allowList]. + * Add a [keyword] to [allowedKeywords][KeywordPresetAutoModerationRuleBuilder.allowedKeywords]. * * A keyword can be a phrase which contains multiple words. */ -public fun KeywordPresetAutoModerationRuleBuilder.allow(keyword: String) { - allowList?.add(keyword) ?: run { allowList = mutableListOf(keyword) } +public fun KeywordPresetAutoModerationRuleBuilder.allowKeyword(keyword: String) { + allowedKeywords?.add(keyword) ?: run { allowedKeywords = mutableListOf(keyword) } } diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt index 520ec189caf3..4cd58def069c 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt @@ -102,12 +102,12 @@ public class KeywordPresetAutoModerationRuleCreateBuilder( this.presets = presets } - private var _allowList: Optional> = Optional.Missing() - override var allowList: MutableList? by ::_allowList.delegate() + private var _allowedKeywords: Optional> = Optional.Missing() + override var allowedKeywords: MutableList? by ::_allowedKeywords.delegate() override fun buildTriggerMetadata(): Optional.Value = DiscordAutoModerationRuleTriggerMetadata( presets = presets.toList().optional(), - allowList = _allowList.map { it.toList() }, + allowList = _allowedKeywords.map { it.toList() }, ).optional() } diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt index 55a3d1ccc9ae..02780f74d36c 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt @@ -111,17 +111,18 @@ public class KeywordPresetAutoModerationRuleModifyBuilder : this.presets = presets } - private var _allowList: Optional> = Optional.Missing() - override var allowList: MutableList? by ::_allowList.delegate() + private var _allowedKeywords: Optional> = Optional.Missing() + override var allowedKeywords: MutableList? by ::_allowedKeywords.delegate() override fun buildTriggerMetadata(): Optional { val presets = _presets - val allowList = _allowList + val allowedKeywords = _allowedKeywords return when { - presets !is Optional.Missing || allowList !is Optional.Missing -> DiscordAutoModerationRuleTriggerMetadata( - presets = presets.map { it.toList() }, - allowList = allowList.map { it.toList() }, - ).optional() + presets !is Optional.Missing || allowedKeywords !is Optional.Missing -> + DiscordAutoModerationRuleTriggerMetadata( + presets = presets.map { it.toList() }, + allowList = allowedKeywords.map { it.toList() }, + ).optional() else -> Optional.Missing() } From 315d8924bfd7ab5f578f5aaa1e4b5d9dd0b085ec Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 8 Aug 2022 00:17:09 +0200 Subject: [PATCH 43/57] Docs for builders --- .../entity/automoderation/AutoModerationRule.kt | 2 +- .../automoderation/AutoModerationActionBuilder.kt | 7 +++++++ .../automoderation/AutoModerationRuleBuilder.kt | 15 +++++++++++++++ .../AutoModerationRuleCreateBuilder.kt | 5 +++++ .../AutoModerationRuleModifyBuilder.kt | 6 ++++++ 5 files changed, 34 insertions(+), 1 deletion(-) diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index d9bd9b6145ef..92aa6b664f52 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -20,7 +20,7 @@ import dev.kord.core.supplier.EntitySupplier import dev.kord.core.supplier.EntitySupplyStrategy /** - * An instance of a [Discord Auto Moderation Rule](https://discord.com/developers/docs/resources/auto-moderation). + * An instance of an [Auto Moderation Rule](https://discord.com/developers/docs/resources/auto-moderation). * * Auto Moderation is a feature which allows each [Guild] to set up rules that trigger based on some criteria. For * example, a rule can trigger whenever a message contains a specific keyword. diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt index 5ddafb26db52..70080e818793 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt @@ -12,6 +12,10 @@ import dev.kord.common.entity.optional.optionalSnowflake import dev.kord.rest.builder.RequestBuilder import kotlin.time.Duration +/** + * A [RequestBuilder] for building [actions][DiscordAutoModerationAction] which will execute whenever a + * [rule][AutoModerationRuleBuilder] is triggered. + */ @KordDsl public sealed class AutoModerationActionBuilder : RequestBuilder { @@ -26,12 +30,14 @@ public sealed class AutoModerationActionBuilder : RequestBuilder Date: Mon, 8 Aug 2022 00:38:07 +0200 Subject: [PATCH 44/57] Bound for type parameter of RequestBuilder --- rest/src/main/kotlin/builder/RequestBuilder.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/rest/src/main/kotlin/builder/RequestBuilder.kt b/rest/src/main/kotlin/builder/RequestBuilder.kt index ef24788825c5..9e5139ec54a1 100644 --- a/rest/src/main/kotlin/builder/RequestBuilder.kt +++ b/rest/src/main/kotlin/builder/RequestBuilder.kt @@ -11,9 +11,9 @@ public interface AuditBuilder { } @KordDsl -public interface RequestBuilder { +public interface RequestBuilder { public fun toRequest(): T } @KordDsl -public interface AuditRequestBuilder : AuditBuilder, RequestBuilder +public interface AuditRequestBuilder : AuditBuilder, RequestBuilder From fbff6751a9bee69b97c5e14c653c8fdf34cb5547 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 8 Aug 2022 21:39:56 +0200 Subject: [PATCH 45/57] Add `MentionSpam` trigger type --- .../src/main/kotlin/entity/AutoModeration.kt | 7 ++ core/src/main/kotlin/Unsafe.kt | 5 ++ .../src/main/kotlin/behavior/GuildBehavior.kt | 40 +++++++++-- .../AutoModerationRuleBehavior.kt | 68 +++++++++++++++++++ .../main/kotlin/cache/data/AutoModeration.kt | 3 + .../automoderation/AutoModerationRule.kt | 19 ++++++ .../AutoModerationActionBuilder.kt | 2 +- .../AutoModerationRuleBuilder.kt | 31 +++++++-- .../AutoModerationRuleCreateBuilder.kt | 22 ++++-- .../AutoModerationRuleModifyBuilder.kt | 21 ++++++ .../kotlin/service/AutoModerationService.kt | 22 ++++++ 11 files changed, 226 insertions(+), 14 deletions(-) diff --git a/common/src/main/kotlin/entity/AutoModeration.kt b/common/src/main/kotlin/entity/AutoModeration.kt index fa3a1e84feca..b18dc0ae357f 100644 --- a/common/src/main/kotlin/entity/AutoModeration.kt +++ b/common/src/main/kotlin/entity/AutoModeration.kt @@ -3,6 +3,7 @@ package dev.kord.common.entity import dev.kord.common.entity.AutoModerationRuleTriggerType.Keyword import dev.kord.common.entity.Permission.ModerateMembers import dev.kord.common.entity.optional.Optional +import dev.kord.common.entity.optional.OptionalInt import dev.kord.common.entity.optional.OptionalSnowflake import dev.kord.common.serialization.DurationInSeconds import kotlinx.serialization.KSerializer @@ -60,6 +61,9 @@ public sealed class AutoModerationRuleTriggerType(public val value: Int) { /** Check if content contains words from internal pre-defined wordsets. */ public object KeywordPreset : AutoModerationRuleTriggerType(4) + /** Check if content contains more mentions than allowed. */ + public object MentionSpam : AutoModerationRuleTriggerType(5) + internal object Serializer : KSerializer { @@ -73,6 +77,7 @@ public sealed class AutoModerationRuleTriggerType(public val value: Int) { 2 -> HarmfulLink 3 -> Spam 4 -> KeywordPreset + 5 -> MentionSpam else -> Unknown(value) } } @@ -85,6 +90,8 @@ public data class DiscordAutoModerationRuleTriggerMetadata( val presets: Optional> = Optional.Missing(), @SerialName("allow_list") val allowList: Optional> = Optional.Missing(), + @SerialName("mention_total_limit") + val mentionTotalLimit: OptionalInt = OptionalInt.Missing, ) @Serializable(with = AutoModerationRuleKeywordPresetType.Serializer::class) diff --git a/core/src/main/kotlin/Unsafe.kt b/core/src/main/kotlin/Unsafe.kt index 79d7b2d12cd0..4d413e85baeb 100644 --- a/core/src/main/kotlin/Unsafe.kt +++ b/core/src/main/kotlin/Unsafe.kt @@ -47,6 +47,11 @@ public class Unsafe(private val kord: Kord) { ruleId: Snowflake, ): KeywordPresetAutoModerationRuleBehavior = KeywordPresetAutoModerationRuleBehavior(guildId, ruleId, kord) + public fun mentionSpamAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + ): MentionSpamAutoModerationRuleBehavior = MentionSpamAutoModerationRuleBehavior(guildId, ruleId, kord) + public fun message(channelId: Snowflake, messageId: Snowflake): MessageBehavior = MessageBehavior(channelId = channelId, messageId = messageId, kord = kord) diff --git a/core/src/main/kotlin/behavior/GuildBehavior.kt b/core/src/main/kotlin/behavior/GuildBehavior.kt index 9c136283a71c..ad8070117033 100644 --- a/core/src/main/kotlin/behavior/GuildBehavior.kt +++ b/core/src/main/kotlin/behavior/GuildBehavior.kt @@ -33,10 +33,7 @@ import dev.kord.gateway.start import dev.kord.rest.Image import dev.kord.rest.NamedFile import dev.kord.rest.builder.auditlog.AuditLogGetRequestBuilder -import dev.kord.rest.builder.automoderation.HarmfulLinkAutoModerationRuleCreateBuilder -import dev.kord.rest.builder.automoderation.KeywordAutoModerationRuleCreateBuilder -import dev.kord.rest.builder.automoderation.KeywordPresetAutoModerationRuleCreateBuilder -import dev.kord.rest.builder.automoderation.SpamAutoModerationRuleCreateBuilder +import dev.kord.rest.builder.automoderation.* import dev.kord.rest.builder.ban.BanCreateBuilder import dev.kord.rest.builder.channel.* import dev.kord.rest.builder.guild.* @@ -1100,6 +1097,9 @@ public suspend fun GuildBehavior.createScheduledEvent( * * This requires the [ManageGuild] permission. * + * @param name the rule name. + * @param eventType the rule [event type][AutoModerationRuleEventType]. + * * @throws RestRequestException if something went wrong during the request. */ public suspend inline fun GuildBehavior.createKeywordAutoModerationRule( @@ -1117,6 +1117,9 @@ public suspend inline fun GuildBehavior.createKeywordAutoModerationRule( * * This requires the [ManageGuild] permission. * + * @param name the rule name. + * @param eventType the rule [event type][AutoModerationRuleEventType]. + * * @throws RestRequestException if something went wrong during the request. */ public suspend inline fun GuildBehavior.createHarmfulLinkAutoModerationRule( @@ -1134,6 +1137,9 @@ public suspend inline fun GuildBehavior.createHarmfulLinkAutoModerationRule( * * This requires the [ManageGuild] permission. * + * @param name the rule name. + * @param eventType the rule [event type][AutoModerationRuleEventType]. + * * @throws RestRequestException if something went wrong during the request. */ public suspend inline fun GuildBehavior.createSpamAutoModerationRule( @@ -1151,6 +1157,9 @@ public suspend inline fun GuildBehavior.createSpamAutoModerationRule( * * This requires the [ManageGuild] permission. * + * @param name the rule name. + * @param eventType the rule [event type][AutoModerationRuleEventType]. + * * @throws RestRequestException if something went wrong during the request. */ public suspend inline fun GuildBehavior.createKeywordPresetAutoModerationRule( @@ -1162,3 +1171,26 @@ public suspend inline fun GuildBehavior.createKeywordPresetAutoModerationRule( val rule = kord.rest.autoModeration.createKeywordPresetAutoModerationRule(guildId = id, name, eventType, builder) return KeywordPresetAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) } + +/** + * Requests to create a new [MentionSpamAutoModerationRule] in this guild and returns it. + * + * This requires the [ManageGuild] permission. + * + * @param name the rule name. + * @param eventType the rule [event type][AutoModerationRuleEventType]. + * @param mentionLimit total number of mentions (role & user) allowed per message (maximum of 50). + * + * @throws RestRequestException if something went wrong during the request. + */ +public suspend inline fun GuildBehavior.createMentionSpamAutoModerationRule( + name: String, + eventType: AutoModerationRuleEventType = MessageSend, + mentionLimit: Int, + builder: MentionSpamAutoModerationRuleCreateBuilder.() -> Unit, +): MentionSpamAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration + .createMentionSpamAutoModerationRule(guildId = id, name, eventType, mentionLimit, builder) + return MentionSpamAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index 0d02a9c0c099..2b5d98134275 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -145,6 +145,7 @@ internal fun TypedAutoModerationRuleBehavior( HarmfulLink -> HarmfulLinkAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) Spam -> SpamAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) KeywordPreset -> KeywordPresetAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) + MentionSpam -> MentionSpamAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) is Unknown -> UnknownAutoModerationRuleBehavior(guildId, ruleId, triggerType, kord, supplier) } @@ -417,6 +418,73 @@ public suspend inline fun KeywordPresetAutoModerationRuleBehavior.edit( } +/** The behavior of a [MentionSpamAutoModerationRule]. */ +public interface MentionSpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { + + override val triggerType: MentionSpam get() = MentionSpam + + /** + * Requests to get this behavior as a [MentionSpamAutoModerationRule]. + * Returns `null` if it wasn't found or if the rule isn't a [MentionSpamAutoModerationRule]. + * + * This requires the [ManageGuild] permission. + * + * @throws RequestException if anything went wrong during the request. + */ + override suspend fun asAutoModerationRuleOrNull(): MentionSpamAutoModerationRule? = + super.asAutoModerationRuleOrNull() as? MentionSpamAutoModerationRule + + /** + * Requests to get this behavior as a [MentionSpamAutoModerationRule]. + * + * This requires the [ManageGuild] permission. + * + * @throws RequestException if anything went wrong during the request. + * @throws EntityNotFoundException if the [MentionSpamAutoModerationRule] wasn't found. + * @throws ClassCastException if the rule isn't a [MentionSpamAutoModerationRule]. + */ + override suspend fun asAutoModerationRule(): MentionSpamAutoModerationRule = + super.asAutoModerationRule() as MentionSpamAutoModerationRule + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): MentionSpamAutoModerationRuleBehavior +} + +internal fun MentionSpamAutoModerationRuleBehavior( + guildId: Snowflake, + ruleId: Snowflake, + kord: Kord, + supplier: EntitySupplier = kord.defaultSupplier, +): MentionSpamAutoModerationRuleBehavior = object : MentionSpamAutoModerationRuleBehavior { + override val guildId get() = guildId + override val id get() = ruleId + override val kord get() = kord + override val supplier get() = supplier + + override fun withStrategy(strategy: EntitySupplyStrategy<*>) = + MentionSpamAutoModerationRuleBehavior(guildId, ruleId, kord, strategy.supply(kord)) + + override fun equals(other: Any?) = autoModerationRuleEquals(other) + override fun hashCode() = autoModerationRuleHashCode() + override fun toString() = + "MentionSpamAutoModerationRuleBehavior(guildId=$guildId, id=$id, kord=$kord, supplier=$supplier)" +} + +/** + * Requests to edit this [MentionSpamAutoModerationRule] and returns the edited rule. + * + * This requires the [ManageGuild] permission. + * + * @throws RestRequestException if something went wrong during the request. + */ +public suspend inline fun MentionSpamAutoModerationRuleBehavior.edit( + builder: MentionSpamAutoModerationRuleModifyBuilder.() -> Unit, +): MentionSpamAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val rule = kord.rest.autoModeration.modifyMentionSpamAutoModerationRule(guildId, ruleId = id, builder) + return MentionSpamAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) +} + + @Suppress("FunctionName") internal fun UnknownAutoModerationRuleBehavior( guildId: Snowflake, diff --git a/core/src/main/kotlin/cache/data/AutoModeration.kt b/core/src/main/kotlin/cache/data/AutoModeration.kt index c748268e5709..4fbba8c7b59d 100644 --- a/core/src/main/kotlin/cache/data/AutoModeration.kt +++ b/core/src/main/kotlin/cache/data/AutoModeration.kt @@ -4,6 +4,7 @@ import dev.kord.cache.api.data.DataDescription import dev.kord.cache.api.data.description import dev.kord.common.entity.* import dev.kord.common.entity.optional.Optional +import dev.kord.common.entity.optional.OptionalInt import dev.kord.common.entity.optional.OptionalSnowflake import dev.kord.common.entity.optional.map import dev.kord.common.serialization.DurationInSeconds @@ -50,6 +51,7 @@ public data class AutoModerationRuleTriggerMetadataData( val keywordFilter: Optional> = Optional.Missing(), val presets: Optional> = Optional.Missing(), val allowList: Optional> = Optional.Missing(), + val mentionTotalLimit: OptionalInt = OptionalInt.Missing, ) { public companion object { public fun from(metadata: DiscordAutoModerationRuleTriggerMetadata): AutoModerationRuleTriggerMetadataData = @@ -58,6 +60,7 @@ public data class AutoModerationRuleTriggerMetadataData( keywordFilter = keywordFilter, presets = presets, allowList = allowList, + mentionTotalLimit = mentionTotalLimit, ) } } diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 92aa6b664f52..499196ea42b6 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -6,6 +6,7 @@ import dev.kord.common.entity.AutoModerationRuleTriggerType import dev.kord.common.entity.AutoModerationRuleTriggerType.* import dev.kord.common.entity.Snowflake import dev.kord.common.entity.optional.orEmpty +import dev.kord.common.entity.optional.value import dev.kord.core.Kord import dev.kord.core.behavior.MemberBehavior import dev.kord.core.behavior.RoleBehavior @@ -110,6 +111,7 @@ internal fun AutoModerationRule( HarmfulLink -> HarmfulLinkAutoModerationRule(data, kord, supplier) Spam -> SpamAutoModerationRule(data, kord, supplier) KeywordPreset -> KeywordPresetAutoModerationRule(data, kord, supplier) + MentionSpam -> MentionSpamAutoModerationRule(data, kord, supplier) is Unknown -> UnknownAutoModerationRule(data, kord, supplier) } @@ -188,6 +190,23 @@ public class KeywordPresetAutoModerationRule(data: AutoModerationRuleData, kord: override fun toString(): String = "KeywordPresetAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" } +/** An [AutoModerationRule] with trigger type [MentionSpam]. */ +public class MentionSpamAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : + AutoModerationRule(data, kord, supplier, expectedTriggerType = MentionSpam), + MentionSpamAutoModerationRuleBehavior { + + /** Total number of mentions (role & user) allowed per message. */ + public val mentionLimit: Int get() = data.triggerMetadata.mentionTotalLimit.value!! + + override suspend fun asAutoModerationRuleOrNull(): MentionSpamAutoModerationRule = this + override suspend fun asAutoModerationRule(): MentionSpamAutoModerationRule = this + + override fun withStrategy(strategy: EntitySupplyStrategy<*>): MentionSpamAutoModerationRule = + MentionSpamAutoModerationRule(data, kord, strategy.supply(kord)) + + override fun toString(): String = "MentionSpamAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" +} + /** An [AutoModerationRule] with trigger type [Unknown]. */ public class UnknownAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = null) { diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt index 70080e818793..190b1e41b493 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationActionBuilder.kt @@ -53,7 +53,7 @@ public class SendAlertMessageAutoModerationActionBuilder( /** An [AutoModerationActionBuilder] for building actions with type [Timeout]. */ @KordDsl public class TimeoutAutoModerationActionBuilder( - /** The timeout duration. */ + /** The timeout duration (maximum of 2419200 seconds (4 weeks)). */ public var duration: Duration, ) : AutoModerationActionBuilder() { diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index 4195bb282fe6..2d68e4ec5b04 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -13,6 +13,10 @@ import kotlin.contracts.InvocationKind.EXACTLY_ONCE import kotlin.contracts.contract import kotlin.time.Duration +// the `val propertyName` and `fun assignPropertyName` pattern let us effectively have `var`s with different +// nullability for getter and setter that allows a common supertype for create and modify builders + + /** * An [AuditBuilder] for building * [Auto Moderation Rules](https://discord.com/developers/docs/resources/auto-moderation). @@ -55,10 +59,10 @@ public sealed interface AutoModerationRuleBuilder : AuditBuilder { /** Whether the rule is enabled (`false` by default). */ public var enabled: Boolean? - /** The IDs of the roles that should not be affected by the rule. */ + /** The IDs of the roles that should not be affected by the rule (maximum of 20). */ public var exemptRoles: MutableList? - /** The IDs of the channels that should not be affected by the rule. */ + /** The IDs of the channels that should not be affected by the rule (maximum of 50). */ public var exemptChannels: MutableList? } @@ -85,12 +89,12 @@ public inline fun AutoModerationRuleBuilder.sendAlertMessage( actions?.add(action) ?: assignActions(mutableListOf(action)) } -/** Exempt a [role][roleId] from being affected by the rule. */ +/** Exempt a [role][roleId] from being affected by the rule (maximum of 20). */ public fun AutoModerationRuleBuilder.exemptRole(roleId: Snowflake) { exemptRoles?.add(roleId) ?: run { exemptRoles = mutableListOf(roleId) } } -/** Exempt a [channel][channelId] from being affected by the rule. */ +/** Exempt a [channel][channelId] from being affected by the rule (maximum of 50). */ public fun AutoModerationRuleBuilder.exemptChannel(channelId: Snowflake) { exemptChannels?.add(channelId) ?: run { exemptChannels = mutableListOf(channelId) } } @@ -129,7 +133,7 @@ public sealed interface KeywordAutoModerationRuleBuilder : TypedAutoModerationRu * * The [ModerateMembers] permission is required to use this action. * - * @param duration the timeout duration. + * @param duration the timeout duration (maximum of 2419200 seconds (4 weeks)). */ public inline fun KeywordAutoModerationRuleBuilder.timeout( duration: Duration, @@ -235,3 +239,20 @@ public fun KeywordPresetAutoModerationRuleBuilder.preset(preset: AutoModerationR public fun KeywordPresetAutoModerationRuleBuilder.allowKeyword(keyword: String) { allowedKeywords?.add(keyword) ?: run { allowedKeywords = mutableListOf(keyword) } } + + +/** An [AutoModerationRuleBuilder] for building rules with trigger type [MentionSpam]. */ +@KordDsl +public sealed interface MentionSpamAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { + + override val triggerType: MentionSpam get() = MentionSpam + + /** Total number of mentions (role & user) allowed per message (maximum of 50). */ + public val mentionLimit: Int? + + /** + * Use this to set [mentionLimit][MentionSpamAutoModerationRuleBuilder.mentionLimit] for + * [MentionSpamAutoModerationRuleBuilder]. + */ + public fun assignMentionLimit(mentionLimit: Int) +} diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt index 9b2a8cb28061..9eb00d48db4b 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt @@ -5,11 +5,8 @@ import dev.kord.common.entity.AutoModerationRuleEventType import dev.kord.common.entity.AutoModerationRuleKeywordPresetType import dev.kord.common.entity.DiscordAutoModerationRuleTriggerMetadata import dev.kord.common.entity.Snowflake -import dev.kord.common.entity.optional.Optional -import dev.kord.common.entity.optional.OptionalBoolean +import dev.kord.common.entity.optional.* import dev.kord.common.entity.optional.delegate.delegate -import dev.kord.common.entity.optional.map -import dev.kord.common.entity.optional.optional import dev.kord.rest.builder.AuditRequestBuilder import dev.kord.rest.json.request.AutoModerationRuleCreateRequest @@ -116,3 +113,20 @@ public class KeywordPresetAutoModerationRuleCreateBuilder( allowList = _allowedKeywords.map { it.toList() }, ).optional() } + +/** A [MentionSpamAutoModerationRuleBuilder] for building [AutoModerationRuleCreateRequest]s. */ +@KordDsl +public class MentionSpamAutoModerationRuleCreateBuilder( + name: String, + eventType: AutoModerationRuleEventType, + override var mentionLimit: Int, +) : AutoModerationRuleCreateBuilder(name, eventType), MentionSpamAutoModerationRuleBuilder { + + /** @suppress Use `this.mentionLimit = mentionLimit` instead. */ + override fun assignMentionLimit(mentionLimit: Int) { + this.mentionLimit = mentionLimit + } + + override fun buildTriggerMetadata(): Optional.Value = + DiscordAutoModerationRuleTriggerMetadata(mentionTotalLimit = mentionLimit.optionalInt()).optional() +} diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt index 7f7bcff69132..ce49d008e2f1 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt @@ -134,3 +134,24 @@ public class KeywordPresetAutoModerationRuleModifyBuilder : } } } + +/** A [MentionSpamAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */ +@KordDsl +public class MentionSpamAutoModerationRuleModifyBuilder : + AutoModerationRuleModifyBuilder(), + MentionSpamAutoModerationRuleBuilder { + + private var _mentionLimit: OptionalInt = OptionalInt.Missing + override var mentionLimit: Int? by ::_mentionLimit.delegate() + + /** @suppress Use `this.mentionLimit = mentionLimit` instead. */ + override fun assignMentionLimit(mentionLimit: Int) { + this.mentionLimit = mentionLimit + } + + override fun buildTriggerMetadata(): Optional = + when (val limit = _mentionLimit) { + OptionalInt.Missing -> Optional.Missing() + is OptionalInt.Value -> DiscordAutoModerationRuleTriggerMetadata(mentionTotalLimit = limit).optional() + } +} diff --git a/rest/src/main/kotlin/service/AutoModerationService.kt b/rest/src/main/kotlin/service/AutoModerationService.kt index 44e1b11bd5ac..1f0cde427c72 100644 --- a/rest/src/main/kotlin/service/AutoModerationService.kt +++ b/rest/src/main/kotlin/service/AutoModerationService.kt @@ -79,6 +79,18 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService return createAutoModerationRule(guildId, request.toRequest(), request.reason) } + public suspend inline fun createMentionSpamAutoModerationRule( + guildId: Snowflake, + name: String, + eventType: AutoModerationRuleEventType, + mentionLimit: Int, + builder: MentionSpamAutoModerationRuleCreateBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = MentionSpamAutoModerationRuleCreateBuilder(name, eventType, mentionLimit).apply(builder) + return createAutoModerationRule(guildId, request.toRequest(), request.reason) + } + public suspend fun modifyAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, @@ -141,6 +153,16 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) } + public suspend inline fun modifyMentionSpamAutoModerationRule( + guildId: Snowflake, + ruleId: Snowflake, + builder: MentionSpamAutoModerationRuleModifyBuilder.() -> Unit, + ): DiscordAutoModerationRule { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val request = MentionSpamAutoModerationRuleModifyBuilder().apply(builder) + return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) + } + public suspend fun deleteAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, From e0d5a16732117460ca19ca04f691f2e0d6afdfd9 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Fri, 19 Aug 2022 18:48:51 +0200 Subject: [PATCH 46/57] Fix after merge --- common/api/common.api | 309 +++++++- core/api/core.api | 698 +++++++++++++++++- .../AutoModerationActionExecutionEvent.kt | 12 +- .../AutoModerationRuleConfigurationEvent.kt | 32 +- .../handler/AutoModerationEventHandler.kt | 34 +- .../handler/DefaultGatewayEventInterceptor.kt | 4 +- rest/api/rest.api | 396 +++++++++- 7 files changed, 1431 insertions(+), 54 deletions(-) diff --git a/common/api/common.api b/common/api/common.api index dfab18a467e2..432d1494154b 100644 --- a/common/api/common.api +++ b/common/api/common.api @@ -884,6 +884,22 @@ public final class dev/kord/common/entity/AuditLogEvent$ApplicationCommandPermis public static final field INSTANCE Ldev/kord/common/entity/AuditLogEvent$ApplicationCommandPermissionUpdate; } +public final class dev/kord/common/entity/AuditLogEvent$AutoModerationBlockMessage : dev/kord/common/entity/AuditLogEvent { + public static final field INSTANCE Ldev/kord/common/entity/AuditLogEvent$AutoModerationBlockMessage; +} + +public final class dev/kord/common/entity/AuditLogEvent$AutoModerationRuleCreate : dev/kord/common/entity/AuditLogEvent { + public static final field INSTANCE Ldev/kord/common/entity/AuditLogEvent$AutoModerationRuleCreate; +} + +public final class dev/kord/common/entity/AuditLogEvent$AutoModerationRuleDelete : dev/kord/common/entity/AuditLogEvent { + public static final field INSTANCE Ldev/kord/common/entity/AuditLogEvent$AutoModerationRuleDelete; +} + +public final class dev/kord/common/entity/AuditLogEvent$AutoModerationRuleUpdate : dev/kord/common/entity/AuditLogEvent { + public static final field INSTANCE Ldev/kord/common/entity/AuditLogEvent$AutoModerationRuleUpdate; +} + public final class dev/kord/common/entity/AuditLogEvent$BotAdd : dev/kord/common/entity/AuditLogEvent { public static final field INSTANCE Ldev/kord/common/entity/AuditLogEvent$BotAdd; } @@ -1080,6 +1096,118 @@ public final class dev/kord/common/entity/AuditLogEvent$WebhookUpdate : dev/kord public static final field INSTANCE Ldev/kord/common/entity/AuditLogEvent$WebhookUpdate; } +public abstract class dev/kord/common/entity/AutoModerationActionType { + public static final field Companion Ldev/kord/common/entity/AutoModerationActionType$Companion; + public synthetic fun (ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun equals (Ljava/lang/Object;)Z + public final fun getValue ()I + public final fun hashCode ()I +} + +public final class dev/kord/common/entity/AutoModerationActionType$BlockMessage : dev/kord/common/entity/AutoModerationActionType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationActionType$BlockMessage; +} + +public final class dev/kord/common/entity/AutoModerationActionType$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/AutoModerationActionType$SendAlertMessage : dev/kord/common/entity/AutoModerationActionType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationActionType$SendAlertMessage; +} + +public final class dev/kord/common/entity/AutoModerationActionType$Timeout : dev/kord/common/entity/AutoModerationActionType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationActionType$Timeout; +} + +public final class dev/kord/common/entity/AutoModerationActionType$Unknown : dev/kord/common/entity/AutoModerationActionType { + public fun (I)V +} + +public abstract class dev/kord/common/entity/AutoModerationRuleEventType { + public static final field Companion Ldev/kord/common/entity/AutoModerationRuleEventType$Companion; + public synthetic fun (ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun equals (Ljava/lang/Object;)Z + public final fun getValue ()I + public final fun hashCode ()I +} + +public final class dev/kord/common/entity/AutoModerationRuleEventType$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/AutoModerationRuleEventType$MessageSend : dev/kord/common/entity/AutoModerationRuleEventType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleEventType$MessageSend; +} + +public final class dev/kord/common/entity/AutoModerationRuleEventType$Unknown : dev/kord/common/entity/AutoModerationRuleEventType { + public fun (I)V +} + +public abstract class dev/kord/common/entity/AutoModerationRuleKeywordPresetType { + public static final field Companion Ldev/kord/common/entity/AutoModerationRuleKeywordPresetType$Companion; + public synthetic fun (ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun equals (Ljava/lang/Object;)Z + public final fun getValue ()I + public final fun hashCode ()I +} + +public final class dev/kord/common/entity/AutoModerationRuleKeywordPresetType$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/AutoModerationRuleKeywordPresetType$Profanity : dev/kord/common/entity/AutoModerationRuleKeywordPresetType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleKeywordPresetType$Profanity; +} + +public final class dev/kord/common/entity/AutoModerationRuleKeywordPresetType$SexualContent : dev/kord/common/entity/AutoModerationRuleKeywordPresetType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleKeywordPresetType$SexualContent; +} + +public final class dev/kord/common/entity/AutoModerationRuleKeywordPresetType$Slurs : dev/kord/common/entity/AutoModerationRuleKeywordPresetType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleKeywordPresetType$Slurs; +} + +public final class dev/kord/common/entity/AutoModerationRuleKeywordPresetType$Unknown : dev/kord/common/entity/AutoModerationRuleKeywordPresetType { + public fun (I)V +} + +public abstract class dev/kord/common/entity/AutoModerationRuleTriggerType { + public static final field Companion Ldev/kord/common/entity/AutoModerationRuleTriggerType$Companion; + public synthetic fun (ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun equals (Ljava/lang/Object;)Z + public final fun getValue ()I + public final fun hashCode ()I +} + +public final class dev/kord/common/entity/AutoModerationRuleTriggerType$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink : dev/kord/common/entity/AutoModerationRuleTriggerType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; +} + +public final class dev/kord/common/entity/AutoModerationRuleTriggerType$Keyword : dev/kord/common/entity/AutoModerationRuleTriggerType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; +} + +public final class dev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset : dev/kord/common/entity/AutoModerationRuleTriggerType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset; +} + +public final class dev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam : dev/kord/common/entity/AutoModerationRuleTriggerType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; +} + +public final class dev/kord/common/entity/AutoModerationRuleTriggerType$Spam : dev/kord/common/entity/AutoModerationRuleTriggerType { + public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleTriggerType$Spam; +} + +public final class dev/kord/common/entity/AutoModerationRuleTriggerType$Unknown : dev/kord/common/entity/AutoModerationRuleTriggerType { + public fun (I)V +} + public abstract interface class dev/kord/common/entity/BaseDiscordApplication { public abstract fun getCoverImage ()Ldev/kord/common/entity/optional/Optional; public abstract fun getCustomInstallUrl ()Ldev/kord/common/entity/optional/Optional; @@ -2094,17 +2222,19 @@ public final class dev/kord/common/entity/DiscordAttachment$Companion { public final class dev/kord/common/entity/DiscordAuditLog { public static final field Companion Ldev/kord/common/entity/DiscordAuditLog$Companion; - public synthetic fun (ILjava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V - public fun (Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;)V + public synthetic fun (ILjava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;)V public final fun component1 ()Ljava/util/List; public final fun component2 ()Ljava/util/List; public final fun component3 ()Ljava/util/List; public final fun component4 ()Ljava/util/List; public final fun component5 ()Ljava/util/List; - public final fun copy (Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;)Ldev/kord/common/entity/DiscordAuditLog; - public static synthetic fun copy$default (Ldev/kord/common/entity/DiscordAuditLog;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;ILjava/lang/Object;)Ldev/kord/common/entity/DiscordAuditLog; + public final fun component6 ()Ljava/util/List; + public final fun copy (Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;)Ldev/kord/common/entity/DiscordAuditLog; + public static synthetic fun copy$default (Ldev/kord/common/entity/DiscordAuditLog;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;ILjava/lang/Object;)Ldev/kord/common/entity/DiscordAuditLog; public fun equals (Ljava/lang/Object;)Z public final fun getAuditLogEntries ()Ljava/util/List; + public final fun getAutoModerationRules ()Ljava/util/List; public final fun getIntegrations ()Ljava/util/List; public final fun getThreads ()Ljava/util/List; public final fun getUsers ()Ljava/util/List; @@ -2249,6 +2379,161 @@ public final class dev/kord/common/entity/DiscordAutoComplete$Companion { public final fun serializer (Lkotlinx/serialization/KSerializer;)Lkotlinx/serialization/KSerializer; } +public final class dev/kord/common/entity/DiscordAutoModerationAction { + public static final field Companion Ldev/kord/common/entity/DiscordAutoModerationAction$Companion; + public synthetic fun (ILdev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;)V + public synthetic fun (Ldev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/AutoModerationActionType; + public final fun component2 ()Ldev/kord/common/entity/optional/Optional; + public final fun copy (Ldev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;)Ldev/kord/common/entity/DiscordAutoModerationAction; + public static synthetic fun copy$default (Ldev/kord/common/entity/DiscordAutoModerationAction;Ldev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;ILjava/lang/Object;)Ldev/kord/common/entity/DiscordAutoModerationAction; + public fun equals (Ljava/lang/Object;)Z + public final fun getMetadata ()Ldev/kord/common/entity/optional/Optional; + public final fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/common/entity/DiscordAutoModerationAction;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/common/entity/DiscordAutoModerationAction$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/common/entity/DiscordAutoModerationAction$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/common/entity/DiscordAutoModerationAction; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/common/entity/DiscordAutoModerationAction;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/DiscordAutoModerationAction$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/DiscordAutoModerationActionMetadata { + public static final field Companion Ldev/kord/common/entity/DiscordAutoModerationActionMetadata$Companion; + public fun ()V + public synthetic fun (ILdev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;)V + public synthetic fun (Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun component2 ()Ldev/kord/common/entity/optional/Optional; + public final fun copy (Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;)Ldev/kord/common/entity/DiscordAutoModerationActionMetadata; + public static synthetic fun copy$default (Ldev/kord/common/entity/DiscordAutoModerationActionMetadata;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;ILjava/lang/Object;)Ldev/kord/common/entity/DiscordAutoModerationActionMetadata; + public fun equals (Ljava/lang/Object;)Z + public final fun getChannelId ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun getDurationSeconds ()Ldev/kord/common/entity/optional/Optional; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/common/entity/DiscordAutoModerationActionMetadata;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/common/entity/DiscordAutoModerationActionMetadata$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/common/entity/DiscordAutoModerationActionMetadata$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/common/entity/DiscordAutoModerationActionMetadata; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/common/entity/DiscordAutoModerationActionMetadata;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/DiscordAutoModerationActionMetadata$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/DiscordAutoModerationRule { + public static final field Companion Ldev/kord/common/entity/DiscordAutoModerationRule$Companion; + public synthetic fun (ILdev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata;Ljava/util/List;ZLjava/util/List;Ljava/util/List;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata;Ljava/util/List;ZLjava/util/List;Ljava/util/List;)V + public final fun component1 ()Ldev/kord/common/entity/Snowflake; + public final fun component10 ()Ljava/util/List; + public final fun component11 ()Ljava/util/List; + public final fun component2 ()Ldev/kord/common/entity/Snowflake; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ldev/kord/common/entity/Snowflake; + public final fun component5 ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun component6 ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public final fun component7 ()Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata; + public final fun component8 ()Ljava/util/List; + public final fun component9 ()Z + public final fun copy (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata;Ljava/util/List;ZLjava/util/List;Ljava/util/List;)Ldev/kord/common/entity/DiscordAutoModerationRule; + public static synthetic fun copy$default (Ldev/kord/common/entity/DiscordAutoModerationRule;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata;Ljava/util/List;ZLjava/util/List;Ljava/util/List;ILjava/lang/Object;)Ldev/kord/common/entity/DiscordAutoModerationRule; + public fun equals (Ljava/lang/Object;)Z + public final fun getActions ()Ljava/util/List; + public final fun getCreatorId ()Ldev/kord/common/entity/Snowflake; + public final fun getEnabled ()Z + public final fun getEventType ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun getExemptChannels ()Ljava/util/List; + public final fun getExemptRoles ()Ljava/util/List; + public final fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public final fun getId ()Ldev/kord/common/entity/Snowflake; + public final fun getName ()Ljava/lang/String; + public final fun getTriggerMetadata ()Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata; + public final fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/common/entity/DiscordAutoModerationRule;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/common/entity/DiscordAutoModerationRule$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/common/entity/DiscordAutoModerationRule$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/common/entity/DiscordAutoModerationRule; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/common/entity/DiscordAutoModerationRule;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/DiscordAutoModerationRule$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata { + public static final field Companion Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata$Companion; + public fun ()V + public synthetic fun (ILdev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;)V + public synthetic fun (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/optional/Optional; + public final fun component2 ()Ldev/kord/common/entity/optional/Optional; + public final fun component3 ()Ldev/kord/common/entity/optional/Optional; + public final fun component4 ()Ldev/kord/common/entity/optional/OptionalInt; + public final fun copy (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;)Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata; + public static synthetic fun copy$default (Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;ILjava/lang/Object;)Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata; + public fun equals (Ljava/lang/Object;)Z + public final fun getAllowList ()Ldev/kord/common/entity/optional/Optional; + public final fun getKeywordFilter ()Ldev/kord/common/entity/optional/Optional; + public final fun getMentionTotalLimit ()Ldev/kord/common/entity/optional/OptionalInt; + public final fun getPresets ()Ldev/kord/common/entity/optional/Optional; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + public final class dev/kord/common/entity/DiscordBotActivity { public static final field Companion Ldev/kord/common/entity/DiscordBotActivity$Companion; public synthetic fun (ILjava/lang/String;Ldev/kord/common/entity/ActivityType;Ldev/kord/common/entity/optional/Optional;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V @@ -5735,8 +6020,10 @@ public final class dev/kord/common/entity/ExplicitContentFilter$Unknown : dev/ko public abstract class dev/kord/common/entity/GuildFeature { public static final field Companion Ldev/kord/common/entity/GuildFeature$Companion; public synthetic fun (Ljava/lang/String;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun equals (Ljava/lang/Object;)Z public final fun getValue ()Ljava/lang/String; - public fun toString ()Ljava/lang/String; + public final fun hashCode ()I + public final fun toString ()Ljava/lang/String; } public final class dev/kord/common/entity/GuildFeature$AnimatedBanner : dev/kord/common/entity/GuildFeature { @@ -5747,6 +6034,10 @@ public final class dev/kord/common/entity/GuildFeature$AnimatedIcon : dev/kord/c public static final field INSTANCE Ldev/kord/common/entity/GuildFeature$AnimatedIcon; } +public final class dev/kord/common/entity/GuildFeature$AutoModeration : dev/kord/common/entity/GuildFeature { + public static final field INSTANCE Ldev/kord/common/entity/GuildFeature$AutoModeration; +} + public final class dev/kord/common/entity/GuildFeature$Banner : dev/kord/common/entity/GuildFeature { public static final field INSTANCE Ldev/kord/common/entity/GuildFeature$Banner; } @@ -6465,9 +6756,13 @@ public final class dev/kord/common/entity/MessageStickerType$Unknown : dev/kord/ public abstract class dev/kord/common/entity/MessageType { public static final field Companion Ldev/kord/common/entity/MessageType$Companion; public synthetic fun (ILkotlin/jvm/internal/DefaultConstructorMarker;)V - public fun equals (Ljava/lang/Object;)Z + public final fun equals (Ljava/lang/Object;)Z public final fun getCode ()I - public fun hashCode ()I + public final fun hashCode ()I +} + +public final class dev/kord/common/entity/MessageType$AutoModerationAction : dev/kord/common/entity/MessageType { + public static final field INSTANCE Ldev/kord/common/entity/MessageType$AutoModerationAction; } public final class dev/kord/common/entity/MessageType$Call : dev/kord/common/entity/MessageType { diff --git a/core/api/core.api b/core/api/core.api index b29ca493e35b..0dcb280f004e 100644 --- a/core/api/core.api +++ b/core/api/core.api @@ -107,6 +107,7 @@ public abstract interface class dev/kord/core/KordObject { public final class dev/kord/core/Unsafe { public fun (Ldev/kord/core/Kord;)V public final fun applicationCommandInteraction (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/interaction/ApplicationCommandInteractionBehavior; + public final fun autoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; public final fun categorizableChannel (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/CategorizableChannelBehavior; public final fun channel (Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/ChannelBehavior; public final fun componentInteraction (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/interaction/ComponentInteractionBehavior; @@ -122,13 +123,18 @@ public final class dev/kord/core/Unsafe { public final fun guildEmoji (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/core/Kord;)Ldev/kord/core/behavior/GuildEmojiBehavior; public final fun guildMessageChannel (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/GuildMessageChannelBehavior; public final fun guildScheduledEvent (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/GuildScheduledEventBehavior; + public final fun harmfulLinkAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior; + public final fun keywordAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior; + public final fun keywordPresetAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior; public final fun member (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/MemberBehavior; + public final fun mentionSpamAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior; public final fun message (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/MessageBehavior; public final fun messageChannel (Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/MessageChannelBehavior; public final fun newsChannel (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/NewsChannelBehavior; public final fun privateThreadParent (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/threads/PrivateThreadParentChannelBehavior; public final fun publicThreadParent (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/threads/ThreadParentChannelBehavior; public final fun role (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/RoleBehavior; + public final fun spamAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior; public final fun stageInstance (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/StageInstanceBehavior; public final fun storeChannel (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/StoreChannelBehavior; public final fun textChannel (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/TextChannelBehavior; @@ -238,6 +244,9 @@ public abstract interface class dev/kord/core/behavior/GuildBehavior : dev/kord/ public abstract fun getApplicationCommand (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public abstract fun getApplicationCommandOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public abstract fun getApplicationCommands (Ljava/lang/Boolean;)Lkotlinx/coroutines/flow/Flow; + public abstract fun getAutoModerationRule (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getAutoModerationRuleOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getAutoModerationRules ()Lkotlinx/coroutines/flow/Flow; public abstract fun getBan (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public abstract fun getBanOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public abstract fun getBans ()Lkotlinx/coroutines/flow/Flow; @@ -308,6 +317,9 @@ public final class dev/kord/core/behavior/GuildBehavior$DefaultImpls { public static fun getApplicationCommandOrNull (Ldev/kord/core/behavior/GuildBehavior;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static fun getApplicationCommands (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/Boolean;)Lkotlinx/coroutines/flow/Flow; public static synthetic fun getApplicationCommands$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/Boolean;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow; + public static fun getAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getAutoModerationRuleOrNull (Ldev/kord/core/behavior/GuildBehavior;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getAutoModerationRules (Ldev/kord/core/behavior/GuildBehavior;)Lkotlinx/coroutines/flow/Flow; public static fun getBan (Ldev/kord/core/behavior/GuildBehavior;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static fun getBanOrNull (Ldev/kord/core/behavior/GuildBehavior;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static fun getBans (Ldev/kord/core/behavior/GuildBehavior;)Lkotlinx/coroutines/flow/Flow; @@ -382,6 +394,14 @@ public final class dev/kord/core/behavior/GuildBehaviorKt { public static final fun createEmoji (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/rest/Image;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static final fun createEmoji (Ldev/kord/core/behavior/GuildBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun createEmoji$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/rest/Image;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; + public static final fun createHarmfulLinkAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun createHarmfulLinkAutoModerationRule$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; + public static final fun createKeywordAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun createKeywordAutoModerationRule$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; + public static final fun createKeywordPresetAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun createKeywordPresetAutoModerationRule$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; + public static final fun createMentionSpamAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;ILkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun createMentionSpamAutoModerationRule$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;ILkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; public static final fun createMessageCommand (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun createMessageCommand$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; public static final fun createNewsChannel (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; @@ -390,6 +410,8 @@ public final class dev/kord/core/behavior/GuildBehaviorKt { public static final fun createRole (Ldev/kord/core/behavior/GuildBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun createRole$default (Ldev/kord/core/behavior/GuildBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; public static final fun createScheduledEvent (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/GuildScheduledEventPrivacyLevel;Lkotlinx/datetime/Instant;Ldev/kord/common/entity/ScheduledEntityType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static final fun createSpamAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun createSpamAutoModerationRule$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; public static final fun createTextChannel (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static final fun createTextChannel (Ldev/kord/core/behavior/GuildBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun createTextChannel$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; @@ -837,6 +859,146 @@ public final class dev/kord/core/behavior/WebhookBehaviorKt { public static synthetic fun executeIgnored$default (Ldev/kord/core/behavior/WebhookBehavior;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; } +public abstract interface class dev/kord/core/behavior/automoderation/AutoModerationRuleBehavior : dev/kord/core/entity/KordEntity, dev/kord/core/entity/Strategizable { + public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun delete (Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun equals (Ljava/lang/Object;)Z + public abstract fun getGuild ()Ldev/kord/core/behavior/GuildBehavior; + public abstract fun getGuild (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public abstract fun getGuildOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public abstract fun hashCode ()I + public abstract fun toString ()Ljava/lang/String; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; +} + +public final class dev/kord/core/behavior/automoderation/AutoModerationRuleBehavior$DefaultImpls { + public static fun asAutoModerationRule (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun asAutoModerationRuleOrNull (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun compareTo (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Ldev/kord/core/entity/Entity;)I + public static fun delete (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun delete$default (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildOrNull (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; +} + +public final class dev/kord/core/behavior/automoderation/AutoModerationRuleBehaviorKt { + public static final fun edit (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static final fun edit (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static final fun edit (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static final fun edit (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static final fun edit (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static final fun edit (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; +} + +public abstract interface class dev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior : dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior { + public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior; +} + +public final class dev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior$DefaultImpls { + public static fun asAutoModerationRule (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun asAutoModerationRuleOrNull (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun compareTo (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Ldev/kord/core/entity/Entity;)I + public static fun delete (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildOrNull (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getTriggerType (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; +} + +public abstract interface class dev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior : dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior { + public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior; +} + +public final class dev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior$DefaultImpls { + public static fun asAutoModerationRule (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun asAutoModerationRuleOrNull (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun compareTo (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;Ldev/kord/core/entity/Entity;)I + public static fun delete (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildOrNull (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getTriggerType (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; +} + +public abstract interface class dev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior : dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior { + public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior; +} + +public final class dev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior$DefaultImpls { + public static fun asAutoModerationRule (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun asAutoModerationRuleOrNull (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun compareTo (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;Ldev/kord/core/entity/Entity;)I + public static fun delete (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildOrNull (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getTriggerType (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset; +} + +public abstract interface class dev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior : dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior { + public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior; +} + +public final class dev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior$DefaultImpls { + public static fun asAutoModerationRule (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun asAutoModerationRuleOrNull (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun compareTo (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;Ldev/kord/core/entity/Entity;)I + public static fun delete (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildOrNull (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getTriggerType (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; +} + +public abstract interface class dev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior : dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior { + public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Spam; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior; +} + +public final class dev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior$DefaultImpls { + public static fun asAutoModerationRule (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun asAutoModerationRuleOrNull (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun compareTo (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;Ldev/kord/core/entity/Entity;)I + public static fun delete (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildOrNull (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getTriggerType (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$Spam; +} + +public abstract interface class dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior : dev/kord/core/behavior/automoderation/AutoModerationRuleBehavior { + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; +} + +public final class dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior$DefaultImpls { + public static fun asAutoModerationRule (Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun asAutoModerationRuleOrNull (Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun compareTo (Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior;Ldev/kord/core/entity/Entity;)I + public static fun delete (Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildOrNull (Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; +} + public abstract interface class dev/kord/core/behavior/channel/BaseVoiceChannelBehavior : dev/kord/core/behavior/channel/CategorizableChannelBehavior { public abstract fun getVoiceStates ()Lkotlinx/coroutines/flow/Flow; } @@ -2588,6 +2750,166 @@ public final class dev/kord/core/cache/data/AttachmentData$Companion { public final fun serializer ()Lkotlinx/serialization/KSerializer; } +public final class dev/kord/core/cache/data/AutoModerationActionData { + public static final field Companion Ldev/kord/core/cache/data/AutoModerationActionData$Companion; + public synthetic fun (ILdev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;)V + public synthetic fun (Ldev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/AutoModerationActionType; + public final fun component2 ()Ldev/kord/common/entity/optional/Optional; + public final fun copy (Ldev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;)Ldev/kord/core/cache/data/AutoModerationActionData; + public static synthetic fun copy$default (Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/common/entity/AutoModerationActionType;Ldev/kord/common/entity/optional/Optional;ILjava/lang/Object;)Ldev/kord/core/cache/data/AutoModerationActionData; + public fun equals (Ljava/lang/Object;)Z + public final fun getMetadata ()Ldev/kord/common/entity/optional/Optional; + public final fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/core/cache/data/AutoModerationActionData;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/core/cache/data/AutoModerationActionData$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/core/cache/data/AutoModerationActionData$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/core/cache/data/AutoModerationActionData; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/core/cache/data/AutoModerationActionData;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/core/cache/data/AutoModerationActionData$Companion { + public final fun from (Ldev/kord/common/entity/DiscordAutoModerationAction;)Ldev/kord/core/cache/data/AutoModerationActionData; + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/core/cache/data/AutoModerationActionMetadataData { + public static final field Companion Ldev/kord/core/cache/data/AutoModerationActionMetadataData$Companion; + public fun ()V + public synthetic fun (ILdev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;)V + public synthetic fun (Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun component2 ()Ldev/kord/common/entity/optional/Optional; + public final fun copy (Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;)Ldev/kord/core/cache/data/AutoModerationActionMetadataData; + public static synthetic fun copy$default (Ldev/kord/core/cache/data/AutoModerationActionMetadataData;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;ILjava/lang/Object;)Ldev/kord/core/cache/data/AutoModerationActionMetadataData; + public fun equals (Ljava/lang/Object;)Z + public final fun getChannelId ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun getDurationSeconds ()Ldev/kord/common/entity/optional/Optional; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/core/cache/data/AutoModerationActionMetadataData;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/core/cache/data/AutoModerationActionMetadataData$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/core/cache/data/AutoModerationActionMetadataData$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/core/cache/data/AutoModerationActionMetadataData; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/core/cache/data/AutoModerationActionMetadataData;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/core/cache/data/AutoModerationActionMetadataData$Companion { + public final fun from (Ldev/kord/common/entity/DiscordAutoModerationActionMetadata;)Ldev/kord/core/cache/data/AutoModerationActionMetadataData; + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/core/cache/data/AutoModerationRuleData { + public static final field Companion Ldev/kord/core/cache/data/AutoModerationRuleData$Companion; + public synthetic fun (ILdev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData;Ljava/util/List;ZLjava/util/List;Ljava/util/List;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData;Ljava/util/List;ZLjava/util/List;Ljava/util/List;)V + public final fun component1 ()Ldev/kord/common/entity/Snowflake; + public final fun component10 ()Ljava/util/List; + public final fun component11 ()Ljava/util/List; + public final fun component2 ()Ldev/kord/common/entity/Snowflake; + public final fun component3 ()Ljava/lang/String; + public final fun component4 ()Ldev/kord/common/entity/Snowflake; + public final fun component5 ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun component6 ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public final fun component7 ()Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData; + public final fun component8 ()Ljava/util/List; + public final fun component9 ()Z + public final fun copy (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData;Ljava/util/List;ZLjava/util/List;Ljava/util/List;)Ldev/kord/core/cache/data/AutoModerationRuleData; + public static synthetic fun copy$default (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData;Ljava/util/List;ZLjava/util/List;Ljava/util/List;ILjava/lang/Object;)Ldev/kord/core/cache/data/AutoModerationRuleData; + public fun equals (Ljava/lang/Object;)Z + public final fun getActions ()Ljava/util/List; + public final fun getCreatorId ()Ldev/kord/common/entity/Snowflake; + public final fun getEnabled ()Z + public final fun getEventType ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun getExemptChannels ()Ljava/util/List; + public final fun getExemptRoles ()Ljava/util/List; + public final fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public final fun getId ()Ldev/kord/common/entity/Snowflake; + public final fun getName ()Ljava/lang/String; + public final fun getTriggerMetadata ()Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData; + public final fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/core/cache/data/AutoModerationRuleData;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/core/cache/data/AutoModerationRuleData$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/core/cache/data/AutoModerationRuleData$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/core/cache/data/AutoModerationRuleData; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/core/cache/data/AutoModerationRuleData;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/core/cache/data/AutoModerationRuleData$Companion { + public final fun from (Ldev/kord/common/entity/DiscordAutoModerationRule;)Ldev/kord/core/cache/data/AutoModerationRuleData; + public final fun getDescription ()Ldev/kord/cache/api/data/DataDescription; + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData { + public static final field Companion Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData$Companion; + public fun ()V + public synthetic fun (ILdev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;)V + public synthetic fun (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/optional/Optional; + public final fun component2 ()Ldev/kord/common/entity/optional/Optional; + public final fun component3 ()Ldev/kord/common/entity/optional/Optional; + public final fun component4 ()Ldev/kord/common/entity/optional/OptionalInt; + public final fun copy (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;)Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData; + public static synthetic fun copy$default (Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalInt;ILjava/lang/Object;)Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData; + public fun equals (Ljava/lang/Object;)Z + public final fun getAllowList ()Ldev/kord/common/entity/optional/Optional; + public final fun getKeywordFilter ()Ldev/kord/common/entity/optional/Optional; + public final fun getMentionTotalLimit ()Ldev/kord/common/entity/optional/OptionalInt; + public final fun getPresets ()Ldev/kord/common/entity/optional/Optional; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData$Companion { + public final fun from (Ldev/kord/common/entity/DiscordAutoModerationRuleTriggerMetadata;)Ldev/kord/core/cache/data/AutoModerationRuleTriggerMetadataData; + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + public final class dev/kord/core/cache/data/BanData { public static final field Companion Ldev/kord/core/cache/data/BanData$Companion; public synthetic fun (ILjava/lang/String;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V @@ -5554,6 +5876,7 @@ public final class dev/kord/core/entity/AttachmentKt { public final class dev/kord/core/entity/AuditLog : dev/kord/core/KordObject { public fun (Ldev/kord/common/entity/DiscordAuditLog;Ldev/kord/common/entity/Snowflake;Ldev/kord/core/Kord;)V + public final fun getAutoModerationRules ()Ljava/util/List; public final fun getData ()Ldev/kord/common/entity/DiscordAuditLog; public final fun getEntries ()Ljava/util/List; public final fun getGuildId ()Ldev/kord/common/entity/Snowflake; @@ -5836,6 +6159,9 @@ public final class dev/kord/core/entity/Guild : dev/kord/core/behavior/GuildBeha public final fun getApplicationId ()Ldev/kord/common/entity/Snowflake; public final fun getApproximateMemberCount ()Ljava/lang/Integer; public final fun getApproximatePresenceCount ()Ljava/lang/Integer; + public fun getAutoModerationRule (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRuleOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRules ()Lkotlinx/coroutines/flow/Flow; public fun getBan (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getBanOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun getBanner (Ldev/kord/rest/Image$Format;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; @@ -6398,6 +6724,9 @@ public final class dev/kord/core/entity/PartialGuild : dev/kord/core/behavior/Gu public fun getApplicationCommand (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getApplicationCommandOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getApplicationCommands (Ljava/lang/Boolean;)Lkotlinx/coroutines/flow/Flow; + public fun getAutoModerationRule (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRuleOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRules ()Lkotlinx/coroutines/flow/Flow; public fun getBan (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getBanOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun getBanner (Ldev/kord/rest/Image$Format;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; @@ -7254,6 +7583,172 @@ public final class dev/kord/core/entity/application/UserCommand$DefaultImpls { public static fun getVersion (Ldev/kord/core/entity/application/UserCommand;)Ldev/kord/common/entity/Snowflake; } +public abstract class dev/kord/core/entity/automoderation/AutoModerationAction : dev/kord/core/KordObject { + public synthetic fun (Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/core/Kord;Ldev/kord/common/entity/AutoModerationActionType;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun getData ()Ldev/kord/core/cache/data/AutoModerationActionData; + public final fun getKord ()Ldev/kord/core/Kord; + public abstract fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public abstract fun toString ()Ljava/lang/String; +} + +public abstract class dev/kord/core/entity/automoderation/AutoModerationRule : dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior { + public synthetic fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun compareTo (Ldev/kord/core/entity/Entity;)I + public synthetic fun compareTo (Ljava/lang/Object;)I + public fun delete (Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun equals (Ljava/lang/Object;)Z + public final fun getActions ()Ljava/util/List; + public final fun getCreator ()Ldev/kord/core/behavior/MemberBehavior; + public final fun getCreatorId ()Ldev/kord/common/entity/Snowflake; + public final fun getData ()Ldev/kord/core/cache/data/AutoModerationRuleData; + public final fun getEventType ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun getExemptChannelIds ()Ljava/util/List; + public final fun getExemptChannels ()Ljava/util/List; + public final fun getExemptRoleIds ()Ljava/util/List; + public final fun getExemptRoles ()Ljava/util/List; + public fun getGuild ()Ldev/kord/core/behavior/GuildBehavior; + public fun getGuild (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public fun getGuildOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun getId ()Ldev/kord/common/entity/Snowflake; + public final fun getKord ()Ldev/kord/core/Kord; + public final fun getName ()Ljava/lang/String; + public final fun getSupplier ()Ldev/kord/core/supplier/EntitySupplier; + public final fun hashCode ()I + public final fun isEnabled ()Z + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/AutoModerationRule; +} + +public final class dev/kord/core/entity/automoderation/AutoModerationRuleKt { + public static final fun AutoModerationRule (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)Ldev/kord/core/entity/automoderation/AutoModerationRule; + public static synthetic fun AutoModerationRule$default (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;ILjava/lang/Object;)Ldev/kord/core/entity/automoderation/AutoModerationRule; +} + +public final class dev/kord/core/entity/automoderation/BlockMessageAutoModerationAction : dev/kord/core/entity/automoderation/AutoModerationAction { + public fun (Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/core/Kord;)V + public fun getType ()Ldev/kord/common/entity/AutoModerationActionType$BlockMessage; + public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public fun toString ()Ljava/lang/String; +} + +public final class dev/kord/core/entity/automoderation/HarmfulLinkAutoModerationRule : dev/kord/core/entity/automoderation/AutoModerationRule, dev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior { + public fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)V + public fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/HarmfulLinkAutoModerationRule; +} + +public final class dev/kord/core/entity/automoderation/KeywordAutoModerationRule : dev/kord/core/entity/automoderation/AutoModerationRule, dev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior { + public fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)V + public fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun getKeywords ()Ljava/util/List; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/KeywordAutoModerationRule; +} + +public final class dev/kord/core/entity/automoderation/KeywordPresetAutoModerationRule : dev/kord/core/entity/automoderation/AutoModerationRule, dev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior { + public fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)V + public fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun getAllowedKeywords ()Ljava/util/List; + public final fun getPresets ()Ljava/util/List; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/KeywordPresetAutoModerationRule; +} + +public final class dev/kord/core/entity/automoderation/MentionSpamAutoModerationRule : dev/kord/core/entity/automoderation/AutoModerationRule, dev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior { + public fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)V + public fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun getMentionLimit ()I + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/MentionSpamAutoModerationRule; +} + +public final class dev/kord/core/entity/automoderation/SendAlertMessageAutoModerationAction : dev/kord/core/entity/automoderation/AutoModerationAction { + public fun (Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/core/Kord;)V + public final fun getChannelId ()Ldev/kord/common/entity/Snowflake; + public fun getType ()Ldev/kord/common/entity/AutoModerationActionType$SendAlertMessage; + public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public fun toString ()Ljava/lang/String; +} + +public final class dev/kord/core/entity/automoderation/SpamAutoModerationRule : dev/kord/core/entity/automoderation/AutoModerationRule, dev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior { + public fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)V + public fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Spam; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/SpamAutoModerationRule; +} + +public final class dev/kord/core/entity/automoderation/TimeoutAutoModerationAction : dev/kord/core/entity/automoderation/AutoModerationAction { + public fun (Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/core/Kord;)V + public final fun getDuration-UwyO8pc ()J + public fun getType ()Ldev/kord/common/entity/AutoModerationActionType$Timeout; + public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public fun toString ()Ljava/lang/String; +} + +public final class dev/kord/core/entity/automoderation/UnknownAutoModerationAction : dev/kord/core/entity/automoderation/AutoModerationAction { + public fun (Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/core/Kord;)V + public fun getType ()Ldev/kord/common/entity/AutoModerationActionType$Unknown; + public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public fun toString ()Ljava/lang/String; +} + +public final class dev/kord/core/entity/automoderation/UnknownAutoModerationRule : dev/kord/core/entity/automoderation/AutoModerationRule { + public fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)V + public fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Unknown; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/UnknownAutoModerationRule; +} + public abstract interface class dev/kord/core/entity/channel/CategorizableChannel : dev/kord/core/behavior/channel/CategorizableChannelBehavior, dev/kord/core/entity/channel/TopGuildChannel { public abstract fun getCategory ()Ldev/kord/core/behavior/channel/CategoryBehavior; public abstract fun getCategoryId ()Ldev/kord/common/entity/Snowflake; @@ -10193,10 +10688,9 @@ public final class dev/kord/core/entity/interaction/response/PublicMessageIntera public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/interaction/response/PublicMessageInteractionResponse; } -public abstract interface class dev/kord/core/event/Event { +public abstract interface class dev/kord/core/event/Event : dev/kord/core/KordObject { public abstract fun getCustomContext ()Ljava/lang/Object; public abstract fun getGateway ()Ldev/kord/gateway/Gateway; - public abstract fun getKord ()Ldev/kord/core/Kord; public abstract fun getShard ()I } @@ -10204,6 +10698,192 @@ public final class dev/kord/core/event/Event$DefaultImpls { public static fun getGateway (Ldev/kord/core/event/Event;)Ldev/kord/gateway/Gateway; } +public final class dev/kord/core/event/automoderation/AutoModerationActionExecutionEvent : dev/kord/core/event/automoderation/AutoModerationEvent { + public fun (Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData;Ldev/kord/core/Kord;ILjava/lang/Object;Ldev/kord/core/supplier/EntitySupplier;)V + public synthetic fun (Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData;Ldev/kord/core/Kord;ILjava/lang/Object;Ldev/kord/core/supplier/EntitySupplier;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun getAction ()Ldev/kord/core/entity/automoderation/AutoModerationAction; + public final fun getAlertSystemMessage ()Ldev/kord/core/behavior/MessageBehavior; + public final fun getAlertSystemMessageId ()Ldev/kord/common/entity/Snowflake; + public final fun getChannel ()Ldev/kord/core/behavior/channel/GuildMessageChannelBehavior; + public final fun getChannelId ()Ldev/kord/common/entity/Snowflake; + public final fun getContent ()Ljava/lang/String; + public fun getCustomContext ()Ljava/lang/Object; + public final fun getData ()Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData; + public fun getGateway ()Ldev/kord/gateway/Gateway; + public fun getGuild ()Ldev/kord/core/behavior/GuildBehavior; + public fun getGuild (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public fun getGuildOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getKord ()Ldev/kord/core/Kord; + public final fun getMatchedContent ()Ljava/lang/String; + public final fun getMatchedKeyword ()Ljava/lang/String; + public final fun getMessage ()Ldev/kord/core/behavior/MessageBehavior; + public final fun getMessageId ()Ldev/kord/common/entity/Snowflake; + public fun getRule ()Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public fun getRuleId ()Ldev/kord/common/entity/Snowflake; + public fun getShard ()I + public fun getSupplier ()Ldev/kord/core/supplier/EntitySupplier; + public final fun getUser ()Ldev/kord/core/behavior/MemberBehavior; + public final fun getUserId ()Ldev/kord/common/entity/Snowflake; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationActionExecutionEvent; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationEvent; +} + +public abstract interface class dev/kord/core/event/automoderation/AutoModerationEvent : dev/kord/core/entity/Strategizable, dev/kord/core/event/Event { + public abstract fun getGuild ()Ldev/kord/core/behavior/GuildBehavior; + public abstract fun getGuild (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public abstract fun getGuildOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getRule ()Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public abstract fun getRuleId ()Ldev/kord/common/entity/Snowflake; + public abstract fun toString ()Ljava/lang/String; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationEvent; +} + +public final class dev/kord/core/event/automoderation/AutoModerationEvent$DefaultImpls { + public static fun getGateway (Ldev/kord/core/event/automoderation/AutoModerationEvent;)Ldev/kord/gateway/Gateway; + public static fun getGuild (Ldev/kord/core/event/automoderation/AutoModerationEvent;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/event/automoderation/AutoModerationEvent;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildOrNull (Ldev/kord/core/event/automoderation/AutoModerationEvent;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; +} + +public abstract interface class dev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent : dev/kord/core/event/automoderation/AutoModerationEvent { + public abstract fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public abstract fun getRule ()Ldev/kord/core/entity/automoderation/AutoModerationRule; + public abstract fun getRuleId ()Ldev/kord/common/entity/Snowflake; + public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent; +} + +public final class dev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent$DefaultImpls { + public static fun getGateway (Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent;)Ldev/kord/gateway/Gateway; + public static fun getGuild (Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent;)Ldev/kord/core/behavior/GuildBehavior; + public static fun getGuild (Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getGuildId (Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent;)Ldev/kord/common/entity/Snowflake; + public static fun getGuildOrNull (Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getRuleId (Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent;)Ldev/kord/common/entity/Snowflake; +} + +public final class dev/kord/core/event/automoderation/AutoModerationRuleCreateEvent : dev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent { + public fun (Ldev/kord/core/entity/automoderation/AutoModerationRule;Ldev/kord/core/Kord;ILjava/lang/Object;Ldev/kord/core/supplier/EntitySupplier;)V + public synthetic fun (Ldev/kord/core/entity/automoderation/AutoModerationRule;Ldev/kord/core/Kord;ILjava/lang/Object;Ldev/kord/core/supplier/EntitySupplier;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public fun getCustomContext ()Ljava/lang/Object; + public fun getGateway ()Ldev/kord/gateway/Gateway; + public fun getGuild ()Ldev/kord/core/behavior/GuildBehavior; + public fun getGuild (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public fun getGuildOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getKord ()Ldev/kord/core/Kord; + public synthetic fun getRule ()Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public fun getRule ()Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun getRuleId ()Ldev/kord/common/entity/Snowflake; + public fun getShard ()I + public fun getSupplier ()Ldev/kord/core/supplier/EntitySupplier; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationEvent; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationRuleCreateEvent; +} + +public final class dev/kord/core/event/automoderation/AutoModerationRuleDeleteEvent : dev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent { + public fun (Ldev/kord/core/entity/automoderation/AutoModerationRule;Ldev/kord/core/Kord;ILjava/lang/Object;Ldev/kord/core/supplier/EntitySupplier;)V + public synthetic fun (Ldev/kord/core/entity/automoderation/AutoModerationRule;Ldev/kord/core/Kord;ILjava/lang/Object;Ldev/kord/core/supplier/EntitySupplier;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public fun getCustomContext ()Ljava/lang/Object; + public fun getGateway ()Ldev/kord/gateway/Gateway; + public fun getGuild ()Ldev/kord/core/behavior/GuildBehavior; + public fun getGuild (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public fun getGuildOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getKord ()Ldev/kord/core/Kord; + public synthetic fun getRule ()Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public fun getRule ()Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun getRuleId ()Ldev/kord/common/entity/Snowflake; + public fun getShard ()I + public fun getSupplier ()Ldev/kord/core/supplier/EntitySupplier; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationEvent; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationRuleDeleteEvent; +} + +public final class dev/kord/core/event/automoderation/AutoModerationRuleUpdateEvent : dev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent { + public fun (Ldev/kord/core/entity/automoderation/AutoModerationRule;Ldev/kord/core/entity/automoderation/AutoModerationRule;Ldev/kord/core/Kord;ILjava/lang/Object;Ldev/kord/core/supplier/EntitySupplier;)V + public synthetic fun (Ldev/kord/core/entity/automoderation/AutoModerationRule;Ldev/kord/core/entity/automoderation/AutoModerationRule;Ldev/kord/core/Kord;ILjava/lang/Object;Ldev/kord/core/supplier/EntitySupplier;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public fun getCustomContext ()Ljava/lang/Object; + public fun getGateway ()Ldev/kord/gateway/Gateway; + public fun getGuild ()Ldev/kord/core/behavior/GuildBehavior; + public fun getGuild (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public fun getGuildOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getKord ()Ldev/kord/core/Kord; + public final fun getOld ()Ldev/kord/core/entity/automoderation/AutoModerationRule; + public synthetic fun getRule ()Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; + public fun getRule ()Ldev/kord/core/entity/automoderation/AutoModerationRule; + public fun getRuleId ()Ldev/kord/common/entity/Snowflake; + public fun getShard ()I + public fun getSupplier ()Ldev/kord/core/supplier/EntitySupplier; + public fun toString ()Ljava/lang/String; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationEvent; + public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationRuleConfigurationEvent; + public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationRuleUpdateEvent; +} + +public final class dev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData { + public static final field Companion Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData$Companion; + public synthetic fun (ILdev/kord/common/entity/Snowflake;Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/Snowflake;Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V + public synthetic fun (Ldev/kord/common/entity/Snowflake;Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/Snowflake; + public final fun component10 ()Ljava/lang/String; + public final fun component11 ()Ljava/lang/String; + public final fun component2 ()Ldev/kord/core/cache/data/AutoModerationActionData; + public final fun component3 ()Ldev/kord/common/entity/Snowflake; + public final fun component4 ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public final fun component5 ()Ldev/kord/common/entity/Snowflake; + public final fun component6 ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun component7 ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun component8 ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun component9 ()Ljava/lang/String; + public final fun copy (Ldev/kord/common/entity/Snowflake;Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData; + public static synthetic fun copy$default (Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData;Ldev/kord/common/entity/Snowflake;Ldev/kord/core/cache/data/AutoModerationActionData;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData; + public fun equals (Ljava/lang/Object;)Z + public final fun getAction ()Ldev/kord/core/cache/data/AutoModerationActionData; + public final fun getAlertSystemMessageId ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun getChannelId ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun getContent ()Ljava/lang/String; + public final fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public final fun getMatchedContent ()Ljava/lang/String; + public final fun getMatchedKeyword ()Ljava/lang/String; + public final fun getMessageId ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun getRuleId ()Ldev/kord/common/entity/Snowflake; + public final fun getRuleTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public final fun getUserId ()Ldev/kord/common/entity/Snowflake; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData$Companion { + public final fun from (Ldev/kord/gateway/DiscordAutoModerationActionExecution;)Ldev/kord/core/event/automoderation/data/AutoModerationActionExecutionEventData; + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + public final class dev/kord/core/event/channel/CategoryCreateEvent : dev/kord/core/event/channel/ChannelCreateEvent { public fun (Ldev/kord/core/entity/channel/Category;ILjava/lang/Object;)V public fun getChannel ()Ldev/kord/core/entity/channel/Category; @@ -12219,6 +12899,7 @@ public final class dev/kord/core/exception/EntityNotFoundException : java/lang/E public final class dev/kord/core/exception/EntityNotFoundException$Companion { public final fun applicationCommandPermissionsNotFound (Ldev/kord/common/entity/Snowflake;)Ljava/lang/Void; + public final fun autoModerationRuleNotFound (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ljava/lang/Void; public final fun banNotFound (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ljava/lang/Void; public final fun emojiNotFound (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ljava/lang/Void; public final fun entityNotFound (Ljava/lang/String;Ldev/kord/common/entity/Snowflake;)Ljava/lang/Void; @@ -12697,6 +13378,9 @@ public final class dev/kord/core/supplier/CacheEntitySupplier : dev/kord/core/su public fun getActiveThreads (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; public fun getApplicationCommandPermissions (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getApplicationCommandPermissionsOrNull (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRuleOrNull (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRules (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; public fun getChannel (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getChannelOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getChannelPins (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; @@ -12785,6 +13469,9 @@ public abstract interface class dev/kord/core/supplier/EntitySupplier { public abstract fun getActiveThreads (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; public abstract fun getApplicationCommandPermissions (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public abstract fun getApplicationCommandPermissionsOrNull (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getAutoModerationRuleOrNull (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public abstract fun getAutoModerationRules (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; public abstract fun getChannel (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public abstract fun getChannelOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public abstract fun getChannelPins (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; @@ -12865,6 +13552,7 @@ public abstract interface class dev/kord/core/supplier/EntitySupplier { public final class dev/kord/core/supplier/EntitySupplier$DefaultImpls { public static fun getApplicationCommandPermissions (Ldev/kord/core/supplier/EntitySupplier;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static fun getAutoModerationRule (Ldev/kord/core/supplier/EntitySupplier;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static fun getChannel (Ldev/kord/core/supplier/EntitySupplier;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun getCurrentUserGuilds$default (Ldev/kord/core/supplier/EntitySupplier;Ljava/lang/Integer;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow; public static fun getEmoji (Ldev/kord/core/supplier/EntitySupplier;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; @@ -12937,6 +13625,9 @@ public final class dev/kord/core/supplier/RestEntitySupplier : dev/kord/core/sup public final fun getAuditLogEntries (Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AuditLogGetRequest;)Lkotlinx/coroutines/flow/Flow; public final fun getAuditLogEntries (Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;)Lkotlinx/coroutines/flow/Flow; public static synthetic fun getAuditLogEntries$default (Ldev/kord/core/supplier/RestEntitySupplier;Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AuditLogGetRequest;ILjava/lang/Object;)Lkotlinx/coroutines/flow/Flow; + public fun getAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRuleOrNull (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRules (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; public fun getChannel (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getChannelOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getChannelPins (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; @@ -13032,6 +13723,9 @@ public final class dev/kord/core/supplier/StoreEntitySupplier : dev/kord/core/su public fun getActiveThreads (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; public fun getApplicationCommandPermissions (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getApplicationCommandPermissionsOrNull (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRuleOrNull (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public fun getAutoModerationRules (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; public fun getChannel (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getChannelOrNull (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public fun getChannelPins (Ldev/kord/common/entity/Snowflake;)Lkotlinx/coroutines/flow/Flow; diff --git a/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt b/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt index f53f1571c9c8..971f0f243cfa 100644 --- a/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt +++ b/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt @@ -16,11 +16,9 @@ import dev.kord.core.entity.automoderation.BlockMessageAutoModerationAction import dev.kord.core.entity.automoderation.SendAlertMessageAutoModerationAction import dev.kord.core.entity.channel.GuildMessageChannel import dev.kord.core.event.automoderation.data.AutoModerationActionExecutionEventData -import dev.kord.core.event.kordCoroutineScope import dev.kord.core.supplier.EntitySupplier import dev.kord.core.supplier.EntitySupplyStrategy import dev.kord.gateway.Intent.MessageContent -import kotlinx.coroutines.CoroutineScope /** * An [AutoModerationEvent] that is sent when an [AutoModerationRule] is triggered and an [AutoModerationAction] is @@ -32,9 +30,9 @@ public class AutoModerationActionExecutionEvent( public val data: AutoModerationActionExecutionEventData, override val kord: Kord, override val shard: Int, + override val customContext: Any?, override val supplier: EntitySupplier = kord.defaultSupplier, - coroutineScope: CoroutineScope = kordCoroutineScope(kord), -) : AutoModerationEvent, CoroutineScope by coroutineScope { +) : AutoModerationEvent { /** The ID of the [Guild] in which the [action] was executed. */ override val guildId: Snowflake get() = data.guildId @@ -123,8 +121,8 @@ public class AutoModerationActionExecutionEvent( public val matchedContent: String? get() = data.matchedContent override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationActionExecutionEvent = - AutoModerationActionExecutionEvent(data, kord, shard, strategy.supply(kord)) + AutoModerationActionExecutionEvent(data, kord, shard, customContext, strategy.supply(kord)) - override fun toString(): String = - "AutoModerationActionExecutionEvent(data=$data, kord=$kord, shard=$shard, supplier=$supplier)" + override fun toString(): String = "AutoModerationActionExecutionEvent(data=$data, kord=$kord, shard=$shard, " + + "customContext=$customContext, supplier=$supplier)" } diff --git a/core/src/main/kotlin/event/automoderation/AutoModerationRuleConfigurationEvent.kt b/core/src/main/kotlin/event/automoderation/AutoModerationRuleConfigurationEvent.kt index df38b777b601..0e13e0454619 100644 --- a/core/src/main/kotlin/event/automoderation/AutoModerationRuleConfigurationEvent.kt +++ b/core/src/main/kotlin/event/automoderation/AutoModerationRuleConfigurationEvent.kt @@ -4,10 +4,8 @@ import dev.kord.common.entity.Permission.ManageGuild import dev.kord.common.entity.Snowflake import dev.kord.core.Kord import dev.kord.core.entity.automoderation.AutoModerationRule -import dev.kord.core.event.kordCoroutineScope import dev.kord.core.supplier.EntitySupplier import dev.kord.core.supplier.EntitySupplyStrategy -import kotlinx.coroutines.CoroutineScope /** * An [AutoModerationEvent] that is sent when an [AutoModerationRule] is configured (i.e. @@ -39,15 +37,15 @@ public class AutoModerationRuleCreateEvent( override val rule: AutoModerationRule, override val kord: Kord, override val shard: Int, + override val customContext: Any?, override val supplier: EntitySupplier = kord.defaultSupplier, - coroutineScope: CoroutineScope = kordCoroutineScope(kord), -) : AutoModerationRuleConfigurationEvent, CoroutineScope by coroutineScope { +) : AutoModerationRuleConfigurationEvent { override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleCreateEvent = - AutoModerationRuleCreateEvent(rule, kord, shard, strategy.supply(kord)) + AutoModerationRuleCreateEvent(rule, kord, shard, customContext, strategy.supply(kord)) - override fun toString(): String = - "AutoModerationRuleCreateEvent(rule=$rule, kord=$kord, shard=$shard, supplier=$supplier)" + override fun toString(): String = "AutoModerationRuleCreateEvent(rule=$rule, kord=$kord, shard=$shard, " + + "customContext=$customContext, supplier=$supplier)" } /** @@ -62,15 +60,15 @@ public class AutoModerationRuleUpdateEvent( public val old: AutoModerationRule?, override val kord: Kord, override val shard: Int, + override val customContext: Any?, override val supplier: EntitySupplier = kord.defaultSupplier, - coroutineScope: CoroutineScope = kordCoroutineScope(kord), -) : AutoModerationRuleConfigurationEvent, CoroutineScope by coroutineScope { +) : AutoModerationRuleConfigurationEvent { override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleUpdateEvent = - AutoModerationRuleUpdateEvent(rule, old, kord, shard, strategy.supply(kord)) + AutoModerationRuleUpdateEvent(rule, old, kord, shard, customContext, strategy.supply(kord)) - override fun toString(): String = - "AutoModerationRuleUpdateEvent(rule=$rule, old=$old, kord=$kord, shard=$shard, supplier=$supplier)" + override fun toString(): String = "AutoModerationRuleUpdateEvent(rule=$rule, old=$old, kord=$kord, shard=$shard, " + + "customContext=$customContext, supplier=$supplier)" } /** @@ -83,13 +81,13 @@ public class AutoModerationRuleDeleteEvent( override val rule: AutoModerationRule, override val kord: Kord, override val shard: Int, + override val customContext: Any?, override val supplier: EntitySupplier = kord.defaultSupplier, - coroutineScope: CoroutineScope = kordCoroutineScope(kord), -) : AutoModerationRuleConfigurationEvent, CoroutineScope by coroutineScope { +) : AutoModerationRuleConfigurationEvent { override fun withStrategy(strategy: EntitySupplyStrategy<*>): AutoModerationRuleDeleteEvent = - AutoModerationRuleDeleteEvent(rule, kord, shard, strategy.supply(kord)) + AutoModerationRuleDeleteEvent(rule, kord, shard, customContext, strategy.supply(kord)) - override fun toString(): String = - "AutoModerationRuleDeleteEvent(rule=$rule, kord=$kord, shard=$shard, supplier=$supplier)" + override fun toString(): String = "AutoModerationRuleDeleteEvent(rule=$rule, kord=$kord, shard=$shard, " + + "customContext=$customContext, supplier=$supplier)" } diff --git a/core/src/main/kotlin/gateway/handler/AutoModerationEventHandler.kt b/core/src/main/kotlin/gateway/handler/AutoModerationEventHandler.kt index e9162092e571..da173374b3fe 100644 --- a/core/src/main/kotlin/gateway/handler/AutoModerationEventHandler.kt +++ b/core/src/main/kotlin/gateway/handler/AutoModerationEventHandler.kt @@ -1,6 +1,5 @@ package dev.kord.core.gateway.handler -import dev.kord.cache.api.DataCache import dev.kord.cache.api.put import dev.kord.cache.api.query import dev.kord.cache.api.remove @@ -11,24 +10,23 @@ import dev.kord.core.entity.automoderation.AutoModerationRule import dev.kord.core.event.automoderation.* import dev.kord.core.event.automoderation.data.AutoModerationActionExecutionEventData import dev.kord.gateway.* -import kotlinx.coroutines.CoroutineScope -internal class AutoModerationEventHandler(cache: DataCache) : BaseGatewayEventHandler(cache) { +internal class AutoModerationEventHandler : BaseGatewayEventHandler() { override suspend fun handle( event: Event, shard: Int, kord: Kord, - coroutineScope: CoroutineScope, + context: LazyContext?, ): AutoModerationEvent? = when (event) { - is AutoModerationRuleCreate -> handleRuleCreate(event, shard, kord, coroutineScope) - is AutoModerationRuleUpdate -> handleRuleUpdate(event, shard, kord, coroutineScope) - is AutoModerationRuleDelete -> handleRuleDelete(event, shard, kord, coroutineScope) + is AutoModerationRuleCreate -> handleRuleCreate(event, shard, kord, context) + is AutoModerationRuleUpdate -> handleRuleUpdate(event, shard, kord, context) + is AutoModerationRuleDelete -> handleRuleDelete(event, shard, kord, context) is AutoModerationActionExecution -> AutoModerationActionExecutionEvent( data = AutoModerationActionExecutionEventData.from(event.actionExecution), kord = kord, shard = shard, - coroutineScope = coroutineScope, + customContext = context?.get(), ) else -> null } @@ -38,27 +36,27 @@ internal class AutoModerationEventHandler(cache: DataCache) : BaseGatewayEventHa event: AutoModerationRuleCreate, shard: Int, kord: Kord, - coroutineScope: CoroutineScope, + context: LazyContext?, ): AutoModerationRuleCreateEvent { val data = AutoModerationRuleData.from(event.rule) - cache.put(data) + kord.cache.put(data) val rule = AutoModerationRule(data, kord) - return AutoModerationRuleCreateEvent(rule = rule, kord = kord, shard = shard, coroutineScope = coroutineScope) + return AutoModerationRuleCreateEvent(rule = rule, kord = kord, shard = shard, customContext = context?.get()) } private suspend fun handleRuleUpdate( event: AutoModerationRuleUpdate, shard: Int, kord: Kord, - coroutineScope: CoroutineScope, + context: LazyContext?, ): AutoModerationRuleUpdateEvent { val data = AutoModerationRuleData.from(event.rule) - val oldData = cache.query { + val oldData = kord.cache.query { idEq(AutoModerationRuleData::id, data.id) idEq(AutoModerationRuleData::guildId, data.guildId) }.singleOrNull() - cache.put(data) + kord.cache.put(data) val rule = AutoModerationRule(data, kord) val old = oldData?.let { AutoModerationRule(it, kord) } @@ -67,7 +65,7 @@ internal class AutoModerationEventHandler(cache: DataCache) : BaseGatewayEventHa old = old, kord = kord, shard = shard, - coroutineScope = coroutineScope, + customContext = context?.get(), ) } @@ -75,15 +73,15 @@ internal class AutoModerationEventHandler(cache: DataCache) : BaseGatewayEventHa event: AutoModerationRuleDelete, shard: Int, kord: Kord, - coroutineScope: CoroutineScope, + context: LazyContext?, ): AutoModerationRuleDeleteEvent { val data = AutoModerationRuleData.from(event.rule) - cache.remove { + kord.cache.remove { idEq(AutoModerationRuleData::id, data.id) idEq(AutoModerationRuleData::guildId, data.guildId) } val rule = AutoModerationRule(data, kord) - return AutoModerationRuleDeleteEvent(rule = rule, kord = kord, shard = shard, coroutineScope = coroutineScope) + return AutoModerationRuleDeleteEvent(rule = rule, kord = kord, shard = shard, customContext = context?.get()) } } diff --git a/core/src/main/kotlin/gateway/handler/DefaultGatewayEventInterceptor.kt b/core/src/main/kotlin/gateway/handler/DefaultGatewayEventInterceptor.kt index b18af7a1f215..f53de35f04ba 100644 --- a/core/src/main/kotlin/gateway/handler/DefaultGatewayEventInterceptor.kt +++ b/core/src/main/kotlin/gateway/handler/DefaultGatewayEventInterceptor.kt @@ -36,10 +36,10 @@ public class DefaultGatewayEventInterceptor @KordPreview public constructor( public constructor() : this(customContextCreator = null) private val listeners = listOf( - AutoModerationEventHandler(cache) + AutoModerationEventHandler(), ChannelEventHandler(), GuildEventHandler(), - InteractionEventHandler() + InteractionEventHandler(), LifeCycleEventHandler(), MessageEventHandler(), ThreadEventHandler(), diff --git a/rest/api/rest.api b/rest/api/rest.api index 41a00bd3a011..ac67e053f728 100644 --- a/rest/api/rest.api +++ b/rest/api/rest.api @@ -66,11 +66,14 @@ public final class dev/kord/rest/NamedFile { public final fun getUrl ()Ljava/lang/String; } -public abstract interface class dev/kord/rest/builder/AuditRequestBuilder : dev/kord/rest/builder/RequestBuilder { +public abstract interface class dev/kord/rest/builder/AuditBuilder { public abstract fun getReason ()Ljava/lang/String; public abstract fun setReason (Ljava/lang/String;)V } +public abstract interface class dev/kord/rest/builder/AuditRequestBuilder : dev/kord/rest/builder/AuditBuilder, dev/kord/rest/builder/RequestBuilder { +} + public abstract interface class dev/kord/rest/builder/RequestBuilder { public abstract fun toRequest ()Ljava/lang/Object; } @@ -89,6 +92,260 @@ public final class dev/kord/rest/builder/auditlog/AuditLogGetRequestBuilder : de public synthetic fun toRequest ()Ljava/lang/Object; } +public abstract class dev/kord/rest/builder/automoderation/AutoModerationActionBuilder : dev/kord/rest/builder/RequestBuilder { + protected fun buildMetadata ()Ldev/kord/common/entity/optional/Optional; + public abstract fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public final fun toRequest ()Ldev/kord/common/entity/DiscordAutoModerationAction; + public synthetic fun toRequest ()Ljava/lang/Object; +} + +public abstract interface class dev/kord/rest/builder/automoderation/AutoModerationRuleBuilder : dev/kord/rest/builder/AuditBuilder { + public abstract fun assignActions (Ljava/util/List;)V + public abstract fun assignEventType (Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public abstract fun assignName (Ljava/lang/String;)V + public abstract fun getActions ()Ljava/util/List; + public abstract fun getEnabled ()Ljava/lang/Boolean; + public abstract fun getEventType ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public abstract fun getExemptChannels ()Ljava/util/List; + public abstract fun getExemptRoles ()Ljava/util/List; + public abstract fun getName ()Ljava/lang/String; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public abstract fun setEnabled (Ljava/lang/Boolean;)V + public abstract fun setExemptChannels (Ljava/util/List;)V + public abstract fun setExemptRoles (Ljava/util/List;)V +} + +public final class dev/kord/rest/builder/automoderation/AutoModerationRuleBuilderKt { + public static final fun allowKeyword (Ldev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleBuilder;Ljava/lang/String;)V + public static final fun anywhereKeyword (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;Ljava/lang/String;)V + public static final fun blockMessage (Ldev/kord/rest/builder/automoderation/AutoModerationRuleBuilder;Lkotlin/jvm/functions/Function1;)V + public static synthetic fun blockMessage$default (Ldev/kord/rest/builder/automoderation/AutoModerationRuleBuilder;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public static final fun exemptChannel (Ldev/kord/rest/builder/automoderation/AutoModerationRuleBuilder;Ldev/kord/common/entity/Snowflake;)V + public static final fun exemptRole (Ldev/kord/rest/builder/automoderation/AutoModerationRuleBuilder;Ldev/kord/common/entity/Snowflake;)V + public static final fun keyword (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;Ljava/lang/String;)V + public static final fun prefixKeyword (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;Ljava/lang/String;)V + public static final fun preset (Ldev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleBuilder;Ldev/kord/common/entity/AutoModerationRuleKeywordPresetType;)V + public static final fun sendAlertMessage (Ldev/kord/rest/builder/automoderation/AutoModerationRuleBuilder;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;)V + public static synthetic fun sendAlertMessage$default (Ldev/kord/rest/builder/automoderation/AutoModerationRuleBuilder;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public static final fun suffixKeyword (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;Ljava/lang/String;)V + public static final fun timeout-8Mi8wO0 (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;JLkotlin/jvm/functions/Function1;)V + public static synthetic fun timeout-8Mi8wO0$default (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;JLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V +} + +public abstract class dev/kord/rest/builder/automoderation/AutoModerationRuleCreateBuilder : dev/kord/rest/builder/AuditRequestBuilder, dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { + public synthetic fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun assignActions (Ljava/util/List;)V + public final fun assignEventType (Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public final fun assignName (Ljava/lang/String;)V + protected fun buildTriggerMetadata ()Ldev/kord/common/entity/optional/Optional; + public final fun getActions ()Ljava/util/List; + public final fun getEnabled ()Ljava/lang/Boolean; + public final fun getEventType ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun getExemptChannels ()Ljava/util/List; + public final fun getExemptRoles ()Ljava/util/List; + public final fun getName ()Ljava/lang/String; + public final fun getReason ()Ljava/lang/String; + public final fun setActions (Ljava/util/List;)V + public final fun setEnabled (Ljava/lang/Boolean;)V + public final fun setEventType (Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public final fun setExemptChannels (Ljava/util/List;)V + public final fun setExemptRoles (Ljava/util/List;)V + public final fun setName (Ljava/lang/String;)V + public final fun setReason (Ljava/lang/String;)V + public final fun toRequest ()Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest; + public synthetic fun toRequest ()Ljava/lang/Object; +} + +public abstract class dev/kord/rest/builder/automoderation/AutoModerationRuleModifyBuilder : dev/kord/rest/builder/AuditRequestBuilder, dev/kord/rest/builder/automoderation/AutoModerationRuleBuilder { + public final fun assignActions (Ljava/util/List;)V + public final fun assignEventType (Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public final fun assignName (Ljava/lang/String;)V + protected fun buildTriggerMetadata ()Ldev/kord/common/entity/optional/Optional; + public final fun getActions ()Ljava/util/List; + public final fun getEnabled ()Ljava/lang/Boolean; + public final fun getEventType ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun getExemptChannels ()Ljava/util/List; + public final fun getExemptRoles ()Ljava/util/List; + public final fun getName ()Ljava/lang/String; + public final fun getReason ()Ljava/lang/String; + public final fun setActions (Ljava/util/List;)V + public final fun setEnabled (Ljava/lang/Boolean;)V + public final fun setEventType (Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public final fun setExemptChannels (Ljava/util/List;)V + public final fun setExemptRoles (Ljava/util/List;)V + public final fun setName (Ljava/lang/String;)V + public final fun setReason (Ljava/lang/String;)V + public final fun toRequest ()Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest; + public synthetic fun toRequest ()Ljava/lang/Object; +} + +public final class dev/kord/rest/builder/automoderation/BlockMessageAutoModerationActionBuilder : dev/kord/rest/builder/automoderation/AutoModerationActionBuilder { + public fun ()V + public fun getType ()Ldev/kord/common/entity/AutoModerationActionType$BlockMessage; + public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; +} + +public abstract interface class dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; +} + +public final class dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder$DefaultImpls { + public static fun getTriggerType (Ldev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; +} + +public final class dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleCreateBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleCreateBuilder, dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder { + public fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; +} + +public final class dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleModifyBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleModifyBuilder, dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder { + public fun ()V + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; +} + +public abstract interface class dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { + public abstract fun assignKeywords (Ljava/util/List;)V + public abstract fun getKeywords ()Ljava/util/List; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; +} + +public final class dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder$DefaultImpls { + public static fun getTriggerType (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; +} + +public final class dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleCreateBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleCreateBuilder, dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder { + public fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public fun assignKeywords (Ljava/util/List;)V + public synthetic fun buildTriggerMetadata ()Ldev/kord/common/entity/optional/Optional; + public fun getKeywords ()Ljava/util/List; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun setKeywords (Ljava/util/List;)V +} + +public final class dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleModifyBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleModifyBuilder, dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder { + public fun ()V + public fun assignKeywords (Ljava/util/List;)V + public fun getKeywords ()Ljava/util/List; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun setKeywords (Ljava/util/List;)V +} + +public abstract interface class dev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { + public abstract fun assignPresets (Ljava/util/List;)V + public abstract fun getAllowedKeywords ()Ljava/util/List; + public abstract fun getPresets ()Ljava/util/List; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset; + public abstract fun setAllowedKeywords (Ljava/util/List;)V +} + +public final class dev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleBuilder$DefaultImpls { + public static fun getTriggerType (Ldev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleBuilder;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset; +} + +public final class dev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleCreateBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleCreateBuilder, dev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleBuilder { + public fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public fun assignPresets (Ljava/util/List;)V + public synthetic fun buildTriggerMetadata ()Ldev/kord/common/entity/optional/Optional; + public fun getAllowedKeywords ()Ljava/util/List; + public fun getPresets ()Ljava/util/List; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun setAllowedKeywords (Ljava/util/List;)V + public fun setPresets (Ljava/util/List;)V +} + +public final class dev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleModifyBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleModifyBuilder, dev/kord/rest/builder/automoderation/KeywordPresetAutoModerationRuleBuilder { + public fun ()V + public fun assignPresets (Ljava/util/List;)V + public fun getAllowedKeywords ()Ljava/util/List; + public fun getPresets ()Ljava/util/List; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$KeywordPreset; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun setAllowedKeywords (Ljava/util/List;)V + public fun setPresets (Ljava/util/List;)V +} + +public abstract interface class dev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { + public abstract fun assignMentionLimit (I)V + public abstract fun getMentionLimit ()Ljava/lang/Integer; + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; +} + +public final class dev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleBuilder$DefaultImpls { + public static fun getTriggerType (Ldev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleBuilder;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; +} + +public final class dev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleCreateBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleCreateBuilder, dev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleBuilder { + public fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;I)V + public fun assignMentionLimit (I)V + public synthetic fun buildTriggerMetadata ()Ldev/kord/common/entity/optional/Optional; + public fun getMentionLimit ()Ljava/lang/Integer; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun setMentionLimit (I)V +} + +public final class dev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleModifyBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleModifyBuilder, dev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleBuilder { + public fun ()V + public fun assignMentionLimit (I)V + public fun getMentionLimit ()Ljava/lang/Integer; + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun setMentionLimit (Ljava/lang/Integer;)V +} + +public final class dev/kord/rest/builder/automoderation/SendAlertMessageAutoModerationActionBuilder : dev/kord/rest/builder/automoderation/AutoModerationActionBuilder { + public fun (Ldev/kord/common/entity/Snowflake;)V + public synthetic fun buildMetadata ()Ldev/kord/common/entity/optional/Optional; + public final fun getChannelId ()Ldev/kord/common/entity/Snowflake; + public fun getType ()Ldev/kord/common/entity/AutoModerationActionType$SendAlertMessage; + public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public final fun setChannelId (Ldev/kord/common/entity/Snowflake;)V +} + +public abstract interface class dev/kord/rest/builder/automoderation/SpamAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Spam; +} + +public final class dev/kord/rest/builder/automoderation/SpamAutoModerationRuleBuilder$DefaultImpls { + public static fun getTriggerType (Ldev/kord/rest/builder/automoderation/SpamAutoModerationRuleBuilder;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$Spam; +} + +public final class dev/kord/rest/builder/automoderation/SpamAutoModerationRuleCreateBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleCreateBuilder, dev/kord/rest/builder/automoderation/SpamAutoModerationRuleBuilder { + public fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;)V + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Spam; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; +} + +public final class dev/kord/rest/builder/automoderation/SpamAutoModerationRuleModifyBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleModifyBuilder, dev/kord/rest/builder/automoderation/SpamAutoModerationRuleBuilder { + public fun ()V + public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Spam; + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; +} + +public final class dev/kord/rest/builder/automoderation/TimeoutAutoModerationActionBuilder : dev/kord/rest/builder/automoderation/AutoModerationActionBuilder { + public synthetic fun (JLkotlin/jvm/internal/DefaultConstructorMarker;)V + public synthetic fun buildMetadata ()Ldev/kord/common/entity/optional/Optional; + public final fun getDuration-UwyO8pc ()J + public fun getType ()Ldev/kord/common/entity/AutoModerationActionType$Timeout; + public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; + public final fun setDuration-LRDsOJo (J)V +} + +public abstract interface class dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleBuilder { + public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; +} + +public final class dev/kord/rest/builder/automoderation/UntypedAutoModerationRuleModifyBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleModifyBuilder { + public fun ()V + public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun getTriggerType ()Ljava/lang/Void; +} + public final class dev/kord/rest/builder/ban/BanCreateBuilder : dev/kord/rest/builder/AuditRequestBuilder { public fun ()V public final fun getDeleteMessagesDays ()Ljava/lang/Integer; @@ -2211,6 +2468,95 @@ public final class dev/kord/rest/json/request/AutoCompleteResponseCreateRequest$ public final fun serializer (Lkotlinx/serialization/KSerializer;)Lkotlinx/serialization/KSerializer; } +public final class dev/kord/rest/json/request/AutoModerationRuleCreateRequest { + public static final field Companion Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest$Companion; + public synthetic fun (ILjava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/optional/Optional;Ljava/util/List;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/optional/Optional;Ljava/util/List;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;)V + public synthetic fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/optional/Optional;Ljava/util/List;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ljava/lang/String; + public final fun component2 ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun component3 ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public final fun component4 ()Ldev/kord/common/entity/optional/Optional; + public final fun component5 ()Ljava/util/List; + public final fun component6 ()Ldev/kord/common/entity/optional/OptionalBoolean; + public final fun component7 ()Ldev/kord/common/entity/optional/Optional; + public final fun component8 ()Ldev/kord/common/entity/optional/Optional; + public final fun copy (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/optional/Optional;Ljava/util/List;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;)Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest; + public static synthetic fun copy$default (Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/optional/Optional;Ljava/util/List;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;ILjava/lang/Object;)Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest; + public fun equals (Ljava/lang/Object;)Z + public final fun getActions ()Ljava/util/List; + public final fun getEnabled ()Ldev/kord/common/entity/optional/OptionalBoolean; + public final fun getEventType ()Ldev/kord/common/entity/AutoModerationRuleEventType; + public final fun getExemptChannels ()Ldev/kord/common/entity/optional/Optional; + public final fun getExemptRoles ()Ldev/kord/common/entity/optional/Optional; + public final fun getName ()Ljava/lang/String; + public final fun getTriggerMetadata ()Ldev/kord/common/entity/optional/Optional; + public final fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/rest/json/request/AutoModerationRuleCreateRequest$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/rest/json/request/AutoModerationRuleCreateRequest$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/rest/json/request/AutoModerationRuleModifyRequest { + public static final field Companion Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest$Companion; + public fun ()V + public synthetic fun (ILdev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;)V + public synthetic fun (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/optional/Optional; + public final fun component2 ()Ldev/kord/common/entity/optional/Optional; + public final fun component3 ()Ldev/kord/common/entity/optional/Optional; + public final fun component4 ()Ldev/kord/common/entity/optional/Optional; + public final fun component5 ()Ldev/kord/common/entity/optional/OptionalBoolean; + public final fun component6 ()Ldev/kord/common/entity/optional/Optional; + public final fun component7 ()Ldev/kord/common/entity/optional/Optional; + public final fun copy (Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;)Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest; + public static synthetic fun copy$default (Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/OptionalBoolean;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;ILjava/lang/Object;)Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest; + public fun equals (Ljava/lang/Object;)Z + public final fun getActions ()Ldev/kord/common/entity/optional/Optional; + public final fun getEnabled ()Ldev/kord/common/entity/optional/OptionalBoolean; + public final fun getEventType ()Ldev/kord/common/entity/optional/Optional; + public final fun getExemptChannels ()Ldev/kord/common/entity/optional/Optional; + public final fun getExemptRoles ()Ldev/kord/common/entity/optional/Optional; + public final fun getName ()Ldev/kord/common/entity/optional/Optional; + public final fun getTriggerMetadata ()Ldev/kord/common/entity/optional/Optional; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/rest/json/request/AutoModerationRuleModifyRequest$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/rest/json/request/AutoModerationRuleModifyRequest$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + public final class dev/kord/rest/json/request/BulkDeleteRequest { public static final field Companion Ldev/kord/rest/json/request/BulkDeleteRequest$Companion; public synthetic fun (ILjava/util/List;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V @@ -5597,6 +5943,30 @@ public final class dev/kord/rest/route/Route$AuditLogGet : dev/kord/rest/route/R public static final field INSTANCE Ldev/kord/rest/route/Route$AuditLogGet; } +public final class dev/kord/rest/route/Route$AutoModerationRuleCreate : dev/kord/rest/route/Route { + public static final field INSTANCE Ldev/kord/rest/route/Route$AutoModerationRuleCreate; +} + +public final class dev/kord/rest/route/Route$AutoModerationRuleDelete : dev/kord/rest/route/Route { + public static final field INSTANCE Ldev/kord/rest/route/Route$AutoModerationRuleDelete; +} + +public final class dev/kord/rest/route/Route$AutoModerationRuleGet : dev/kord/rest/route/Route { + public static final field INSTANCE Ldev/kord/rest/route/Route$AutoModerationRuleGet; +} + +public final class dev/kord/rest/route/Route$AutoModerationRuleId : dev/kord/rest/route/Route$Key { + public static final field INSTANCE Ldev/kord/rest/route/Route$AutoModerationRuleId; +} + +public final class dev/kord/rest/route/Route$AutoModerationRuleModify : dev/kord/rest/route/Route { + public static final field INSTANCE Ldev/kord/rest/route/Route$AutoModerationRuleModify; +} + +public final class dev/kord/rest/route/Route$AutoModerationRulesForGuildList : dev/kord/rest/route/Route { + public static final field INSTANCE Ldev/kord/rest/route/Route$AutoModerationRulesForGuildList; +} + public final class dev/kord/rest/route/Route$BulkMessageDeletePost : dev/kord/rest/route/Route { public static final field INSTANCE Ldev/kord/rest/route/Route$BulkMessageDeletePost; } @@ -6332,6 +6702,29 @@ public final class dev/kord/rest/service/AuditLogService : dev/kord/rest/service public final fun getAuditLogs (Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; } +public final class dev/kord/rest/service/AutoModerationService : dev/kord/rest/service/RestService { + public fun (Ldev/kord/rest/request/RequestHandler;)V + public final fun createAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun createAutoModerationRule$default (Ldev/kord/rest/service/AutoModerationService;Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest;Ljava/lang/String;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; + public final fun createHarmfulLinkAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun createKeywordAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun createKeywordPresetAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun createMentionSpamAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;ILkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun createSpamAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun deleteAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun deleteAutoModerationRule$default (Ldev/kord/rest/service/AutoModerationService;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; + public final fun getAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun listAutoModerationRulesForGuild (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun modifyAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public static synthetic fun modifyAutoModerationRule$default (Ldev/kord/rest/service/AutoModerationService;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest;Ljava/lang/String;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; + public final fun modifyHarmfulLinkAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun modifyKeywordAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun modifyKeywordPresetAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun modifyMentionSpamAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun modifySpamAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; + public final fun modifyUntypedAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; +} + public final class dev/kord/rest/service/ChannelService : dev/kord/rest/service/RestService { public fun (Ldev/kord/rest/request/RequestHandler;)V public final fun addPinnedMessage (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; @@ -6604,6 +6997,7 @@ public final class dev/kord/rest/service/RestClient : dev/kord/rest/service/Rest public fun (Ldev/kord/rest/request/RequestHandler;)V public final fun getApplication ()Ldev/kord/rest/service/ApplicationService; public final fun getAuditLog ()Ldev/kord/rest/service/AuditLogService; + public final fun getAutoModeration ()Ldev/kord/rest/service/AutoModerationService; public final fun getChannel ()Ldev/kord/rest/service/ChannelService; public final fun getEmoji ()Ldev/kord/rest/service/EmojiService; public final fun getGuild ()Ldev/kord/rest/service/GuildService; From 20255414009c97e22e540e443e44922d49ee5bc0 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Fri, 19 Aug 2022 18:49:43 +0200 Subject: [PATCH 47/57] Forgot api dump for gateway --- gateway/api/gateway.api | 111 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 111 insertions(+) diff --git a/gateway/api/gateway.api b/gateway/api/gateway.api index bad679f1ef82..098721301252 100644 --- a/gateway/api/gateway.api +++ b/gateway/api/gateway.api @@ -50,6 +50,58 @@ public final class dev/kord/gateway/ApplicationCommandUpdate : dev/kord/gateway/ public fun toString ()Ljava/lang/String; } +public final class dev/kord/gateway/AutoModerationActionExecution : dev/kord/gateway/DispatchEvent { + public fun (Ldev/kord/gateway/DiscordAutoModerationActionExecution;Ljava/lang/Integer;)V + public final fun component1 ()Ldev/kord/gateway/DiscordAutoModerationActionExecution; + public final fun component2 ()Ljava/lang/Integer; + public final fun copy (Ldev/kord/gateway/DiscordAutoModerationActionExecution;Ljava/lang/Integer;)Ldev/kord/gateway/AutoModerationActionExecution; + public static synthetic fun copy$default (Ldev/kord/gateway/AutoModerationActionExecution;Ldev/kord/gateway/DiscordAutoModerationActionExecution;Ljava/lang/Integer;ILjava/lang/Object;)Ldev/kord/gateway/AutoModerationActionExecution; + public fun equals (Ljava/lang/Object;)Z + public final fun getActionExecution ()Ldev/kord/gateway/DiscordAutoModerationActionExecution; + public fun getSequence ()Ljava/lang/Integer; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class dev/kord/gateway/AutoModerationRuleCreate : dev/kord/gateway/DispatchEvent { + public fun (Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;)V + public final fun component1 ()Ldev/kord/common/entity/DiscordAutoModerationRule; + public final fun component2 ()Ljava/lang/Integer; + public final fun copy (Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;)Ldev/kord/gateway/AutoModerationRuleCreate; + public static synthetic fun copy$default (Ldev/kord/gateway/AutoModerationRuleCreate;Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;ILjava/lang/Object;)Ldev/kord/gateway/AutoModerationRuleCreate; + public fun equals (Ljava/lang/Object;)Z + public final fun getRule ()Ldev/kord/common/entity/DiscordAutoModerationRule; + public fun getSequence ()Ljava/lang/Integer; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class dev/kord/gateway/AutoModerationRuleDelete : dev/kord/gateway/DispatchEvent { + public fun (Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;)V + public final fun component1 ()Ldev/kord/common/entity/DiscordAutoModerationRule; + public final fun component2 ()Ljava/lang/Integer; + public final fun copy (Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;)Ldev/kord/gateway/AutoModerationRuleDelete; + public static synthetic fun copy$default (Ldev/kord/gateway/AutoModerationRuleDelete;Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;ILjava/lang/Object;)Ldev/kord/gateway/AutoModerationRuleDelete; + public fun equals (Ljava/lang/Object;)Z + public final fun getRule ()Ldev/kord/common/entity/DiscordAutoModerationRule; + public fun getSequence ()Ljava/lang/Integer; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + +public final class dev/kord/gateway/AutoModerationRuleUpdate : dev/kord/gateway/DispatchEvent { + public fun (Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;)V + public final fun component1 ()Ldev/kord/common/entity/DiscordAutoModerationRule; + public final fun component2 ()Ljava/lang/Integer; + public final fun copy (Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;)Ldev/kord/gateway/AutoModerationRuleUpdate; + public static synthetic fun copy$default (Ldev/kord/gateway/AutoModerationRuleUpdate;Ldev/kord/common/entity/DiscordAutoModerationRule;Ljava/lang/Integer;ILjava/lang/Object;)Ldev/kord/gateway/AutoModerationRuleUpdate; + public fun equals (Ljava/lang/Object;)Z + public final fun getRule ()Ldev/kord/common/entity/DiscordAutoModerationRule; + public fun getSequence ()Ljava/lang/Integer; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; +} + public final class dev/kord/gateway/ChannelCreate : dev/kord/gateway/DispatchEvent { public fun (Ldev/kord/common/entity/DiscordChannel;Ljava/lang/Integer;)V public final fun component1 ()Ldev/kord/common/entity/DiscordChannel; @@ -218,6 +270,57 @@ public final class dev/kord/gateway/DefaultGatewayKt { public static synthetic fun DefaultGateway$default (Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)Ldev/kord/gateway/DefaultGateway; } +public final class dev/kord/gateway/DiscordAutoModerationActionExecution { + public static final field Companion Ldev/kord/gateway/DiscordAutoModerationActionExecution$Companion; + public synthetic fun (ILdev/kord/common/entity/Snowflake;Ldev/kord/common/entity/DiscordAutoModerationAction;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lkotlinx/serialization/internal/SerializationConstructorMarker;)V + public fun (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/DiscordAutoModerationAction;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V + public synthetic fun (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/DiscordAutoModerationAction;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILkotlin/jvm/internal/DefaultConstructorMarker;)V + public final fun component1 ()Ldev/kord/common/entity/Snowflake; + public final fun component10 ()Ljava/lang/String; + public final fun component11 ()Ljava/lang/String; + public final fun component2 ()Ldev/kord/common/entity/DiscordAutoModerationAction; + public final fun component3 ()Ldev/kord/common/entity/Snowflake; + public final fun component4 ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public final fun component5 ()Ldev/kord/common/entity/Snowflake; + public final fun component6 ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun component7 ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun component8 ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun component9 ()Ljava/lang/String; + public final fun copy (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/DiscordAutoModerationAction;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ldev/kord/gateway/DiscordAutoModerationActionExecution; + public static synthetic fun copy$default (Ldev/kord/gateway/DiscordAutoModerationActionExecution;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/DiscordAutoModerationAction;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/AutoModerationRuleTriggerType;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/OptionalSnowflake;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;ILjava/lang/Object;)Ldev/kord/gateway/DiscordAutoModerationActionExecution; + public fun equals (Ljava/lang/Object;)Z + public final fun getAction ()Ldev/kord/common/entity/DiscordAutoModerationAction; + public final fun getAlertSystemMessageId ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun getChannelId ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun getContent ()Ljava/lang/String; + public final fun getGuildId ()Ldev/kord/common/entity/Snowflake; + public final fun getMatchedContent ()Ljava/lang/String; + public final fun getMatchedKeyword ()Ljava/lang/String; + public final fun getMessageId ()Ldev/kord/common/entity/optional/OptionalSnowflake; + public final fun getRuleId ()Ldev/kord/common/entity/Snowflake; + public final fun getRuleTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; + public final fun getUserId ()Ldev/kord/common/entity/Snowflake; + public fun hashCode ()I + public fun toString ()Ljava/lang/String; + public static final fun write$Self (Ldev/kord/gateway/DiscordAutoModerationActionExecution;Lkotlinx/serialization/encoding/CompositeEncoder;Lkotlinx/serialization/descriptors/SerialDescriptor;)V +} + +public final class dev/kord/gateway/DiscordAutoModerationActionExecution$$serializer : kotlinx/serialization/internal/GeneratedSerializer { + public static final field INSTANCE Ldev/kord/gateway/DiscordAutoModerationActionExecution$$serializer; + public static final synthetic field descriptor Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun childSerializers ()[Lkotlinx/serialization/KSerializer; + public fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ldev/kord/gateway/DiscordAutoModerationActionExecution; + public synthetic fun deserialize (Lkotlinx/serialization/encoding/Decoder;)Ljava/lang/Object; + public fun getDescriptor ()Lkotlinx/serialization/descriptors/SerialDescriptor; + public fun serialize (Lkotlinx/serialization/encoding/Encoder;Ldev/kord/gateway/DiscordAutoModerationActionExecution;)V + public synthetic fun serialize (Lkotlinx/serialization/encoding/Encoder;Ljava/lang/Object;)V + public fun typeParametersSerializers ()[Lkotlinx/serialization/KSerializer; +} + +public final class dev/kord/gateway/DiscordAutoModerationActionExecution$Companion { + public final fun serializer ()Lkotlinx/serialization/KSerializer; +} + public final class dev/kord/gateway/DiscordCreatedInvite { public static final field Companion Ldev/kord/gateway/DiscordCreatedInvite$Companion; public synthetic fun (ILdev/kord/common/entity/Snowflake;Ljava/lang/String;Lkotlinx/datetime/Instant;Ldev/kord/common/entity/optional/OptionalSnowflake;Ldev/kord/common/entity/optional/Optional;Lkotlin/time/Duration;ILdev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;Ldev/kord/common/entity/optional/Optional;ZILkotlinx/serialization/internal/SerializationConstructorMarker;Lkotlin/jvm/internal/DefaultConstructorMarker;)V @@ -1048,6 +1151,14 @@ public abstract class dev/kord/gateway/Intent { public final fun getCode ()Ldev/kord/common/DiscordBitSet; } +public final class dev/kord/gateway/Intent$AutoModerationConfiguration : dev/kord/gateway/Intent { + public static final field INSTANCE Ldev/kord/gateway/Intent$AutoModerationConfiguration; +} + +public final class dev/kord/gateway/Intent$AutoModerationExecution : dev/kord/gateway/Intent { + public static final field INSTANCE Ldev/kord/gateway/Intent$AutoModerationExecution; +} + public final class dev/kord/gateway/Intent$Companion { public final fun getValues ()Ljava/util/Set; } From 694a99d390bf8d8eb3ed442340eeeb6fcd5f3541 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 28 Aug 2022 14:59:47 +0200 Subject: [PATCH 48/57] Remove `AutoModerationRuleTriggerType.HarmfulLink` --- common/api/common.api | 4 -- .../src/main/kotlin/entity/AutoModeration.kt | 4 -- core/api/core.api | 37 ---------- core/src/main/kotlin/Unsafe.kt | 5 -- .../src/main/kotlin/behavior/GuildBehavior.kt | 20 ------ .../AutoModerationRuleBehavior.kt | 68 ------------------- .../automoderation/AutoModerationRule.kt | 15 ---- rest/api/rest.api | 22 ------ .../AutoModerationRuleBuilder.kt | 7 -- .../AutoModerationRuleCreateBuilder.kt | 7 -- .../AutoModerationRuleModifyBuilder.kt | 7 -- .../kotlin/service/AutoModerationService.kt | 21 ------ 12 files changed, 217 deletions(-) diff --git a/common/api/common.api b/common/api/common.api index 432d1494154b..40f75edaa0f7 100644 --- a/common/api/common.api +++ b/common/api/common.api @@ -1184,10 +1184,6 @@ public final class dev/kord/common/entity/AutoModerationRuleTriggerType$Companio public final fun serializer ()Lkotlinx/serialization/KSerializer; } -public final class dev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink : dev/kord/common/entity/AutoModerationRuleTriggerType { - public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; -} - public final class dev/kord/common/entity/AutoModerationRuleTriggerType$Keyword : dev/kord/common/entity/AutoModerationRuleTriggerType { public static final field INSTANCE Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; } diff --git a/common/src/main/kotlin/entity/AutoModeration.kt b/common/src/main/kotlin/entity/AutoModeration.kt index b18dc0ae357f..da1c068c5490 100644 --- a/common/src/main/kotlin/entity/AutoModeration.kt +++ b/common/src/main/kotlin/entity/AutoModeration.kt @@ -52,9 +52,6 @@ public sealed class AutoModerationRuleTriggerType(public val value: Int) { /** Check if content contains words from a user defined list of keywords. */ public object Keyword : AutoModerationRuleTriggerType(1) - /** Check if content contains any harmful links. */ - public object HarmfulLink : AutoModerationRuleTriggerType(2) - /** Check if content represents generic spam. */ public object Spam : AutoModerationRuleTriggerType(3) @@ -74,7 +71,6 @@ public sealed class AutoModerationRuleTriggerType(public val value: Int) { override fun deserialize(decoder: Decoder) = when (val value = decoder.decodeInt()) { 1 -> Keyword - 2 -> HarmfulLink 3 -> Spam 4 -> KeywordPreset 5 -> MentionSpam diff --git a/core/api/core.api b/core/api/core.api index 0dcb280f004e..668972da33fe 100644 --- a/core/api/core.api +++ b/core/api/core.api @@ -123,7 +123,6 @@ public final class dev/kord/core/Unsafe { public final fun guildEmoji (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/core/Kord;)Ldev/kord/core/behavior/GuildEmojiBehavior; public final fun guildMessageChannel (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/channel/GuildMessageChannelBehavior; public final fun guildScheduledEvent (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/GuildScheduledEventBehavior; - public final fun harmfulLinkAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior; public final fun keywordAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior; public final fun keywordPresetAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior; public final fun member (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;)Ldev/kord/core/behavior/MemberBehavior; @@ -394,8 +393,6 @@ public final class dev/kord/core/behavior/GuildBehaviorKt { public static final fun createEmoji (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/rest/Image;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static final fun createEmoji (Ldev/kord/core/behavior/GuildBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun createEmoji$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/rest/Image;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; - public static final fun createHarmfulLinkAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public static synthetic fun createHarmfulLinkAutoModerationRule$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; public static final fun createKeywordAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun createKeywordAutoModerationRule$default (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; public static final fun createKeywordPresetAutoModerationRule (Ldev/kord/core/behavior/GuildBehavior;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; @@ -887,31 +884,12 @@ public final class dev/kord/core/behavior/automoderation/AutoModerationRuleBehav public final class dev/kord/core/behavior/automoderation/AutoModerationRuleBehaviorKt { public static final fun edit (Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public static final fun edit (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static final fun edit (Ldev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static final fun edit (Ldev/kord/core/behavior/automoderation/KeywordPresetAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static final fun edit (Ldev/kord/core/behavior/automoderation/MentionSpamAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static final fun edit (Ldev/kord/core/behavior/automoderation/SpamAutoModerationRuleBehavior;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; } -public abstract interface class dev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior : dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior { - public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; - public abstract fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior; -} - -public final class dev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior$DefaultImpls { - public static fun asAutoModerationRule (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public static fun asAutoModerationRuleOrNull (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public static fun compareTo (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Ldev/kord/core/entity/Entity;)I - public static fun delete (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public static fun getGuild (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;)Ldev/kord/core/behavior/GuildBehavior; - public static fun getGuild (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public static fun getGuildOrNull (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public static fun getTriggerType (Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; -} - public abstract interface class dev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior : dev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior { public abstract fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public abstract fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; @@ -7633,21 +7611,6 @@ public final class dev/kord/core/entity/automoderation/BlockMessageAutoModeratio public fun toString ()Ljava/lang/String; } -public final class dev/kord/core/entity/automoderation/HarmfulLinkAutoModerationRule : dev/kord/core/entity/automoderation/AutoModerationRule, dev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior { - public fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)V - public fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public fun asAutoModerationRuleOrNull (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; - public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; - public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; - public fun toString ()Ljava/lang/String; - public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/AutoModerationRuleBehavior; - public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/HarmfulLinkAutoModerationRuleBehavior; - public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; - public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; - public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/AutoModerationRule; - public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/automoderation/HarmfulLinkAutoModerationRule; -} - public final class dev/kord/core/entity/automoderation/KeywordAutoModerationRule : dev/kord/core/entity/automoderation/AutoModerationRule, dev/kord/core/behavior/automoderation/KeywordAutoModerationRuleBehavior { public fun (Ldev/kord/core/cache/data/AutoModerationRuleData;Ldev/kord/core/Kord;Ldev/kord/core/supplier/EntitySupplier;)V public fun asAutoModerationRule (Lkotlin/coroutines/Continuation;)Ljava/lang/Object; diff --git a/core/src/main/kotlin/Unsafe.kt b/core/src/main/kotlin/Unsafe.kt index ffc2e066af60..162198ab85e2 100644 --- a/core/src/main/kotlin/Unsafe.kt +++ b/core/src/main/kotlin/Unsafe.kt @@ -34,11 +34,6 @@ public class Unsafe(private val kord: Kord) { public fun keywordAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): KeywordAutoModerationRuleBehavior = KeywordAutoModerationRuleBehavior(guildId, ruleId, kord) - public fun harmfulLinkAutoModerationRule( - guildId: Snowflake, - ruleId: Snowflake, - ): HarmfulLinkAutoModerationRuleBehavior = HarmfulLinkAutoModerationRuleBehavior(guildId, ruleId, kord) - public fun spamAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): SpamAutoModerationRuleBehavior = SpamAutoModerationRuleBehavior(guildId, ruleId, kord) diff --git a/core/src/main/kotlin/behavior/GuildBehavior.kt b/core/src/main/kotlin/behavior/GuildBehavior.kt index fdb5fe3244c9..891630dfd050 100644 --- a/core/src/main/kotlin/behavior/GuildBehavior.kt +++ b/core/src/main/kotlin/behavior/GuildBehavior.kt @@ -1128,26 +1128,6 @@ public suspend inline fun GuildBehavior.createKeywordAutoModerationRule( return KeywordAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) } -/** - * Requests to create a new [HarmfulLinkAutoModerationRule] in this guild and returns it. - * - * This requires the [ManageGuild] permission. - * - * @param name the rule name. - * @param eventType the rule [event type][AutoModerationRuleEventType]. - * - * @throws RestRequestException if something went wrong during the request. - */ -public suspend inline fun GuildBehavior.createHarmfulLinkAutoModerationRule( - name: String, - eventType: AutoModerationRuleEventType = MessageSend, - builder: HarmfulLinkAutoModerationRuleCreateBuilder.() -> Unit, -): HarmfulLinkAutoModerationRule { - contract { callsInPlace(builder, EXACTLY_ONCE) } - val rule = kord.rest.autoModeration.createHarmfulLinkAutoModerationRule(guildId = id, name, eventType, builder) - return HarmfulLinkAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) -} - /** * Requests to create a new [SpamAutoModerationRule] in this guild and returns it. * diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index 2b5d98134275..e77016aed01e 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -142,7 +142,6 @@ internal fun TypedAutoModerationRuleBehavior( supplier: EntitySupplier = kord.defaultSupplier, ): TypedAutoModerationRuleBehavior = when (triggerType) { Keyword -> KeywordAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) - HarmfulLink -> HarmfulLinkAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) Spam -> SpamAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) KeywordPreset -> KeywordPresetAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) MentionSpam -> MentionSpamAutoModerationRuleBehavior(guildId, ruleId, kord, supplier) @@ -217,73 +216,6 @@ public suspend inline fun KeywordAutoModerationRuleBehavior.edit( } -/** The behavior of a [HarmfulLinkAutoModerationRule]. */ -public interface HarmfulLinkAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { - - override val triggerType: HarmfulLink get() = HarmfulLink - - /** - * Requests to get this behavior as a [HarmfulLinkAutoModerationRule]. - * Returns `null` if it wasn't found or if the rule isn't a [HarmfulLinkAutoModerationRule]. - * - * This requires the [ManageGuild] permission. - * - * @throws RequestException if anything went wrong during the request. - */ - override suspend fun asAutoModerationRuleOrNull(): HarmfulLinkAutoModerationRule? = - super.asAutoModerationRuleOrNull() as? HarmfulLinkAutoModerationRule - - /** - * Requests to get this behavior as a [HarmfulLinkAutoModerationRule]. - * - * This requires the [ManageGuild] permission. - * - * @throws RequestException if anything went wrong during the request. - * @throws EntityNotFoundException if the [HarmfulLinkAutoModerationRule] wasn't found. - * @throws ClassCastException if the rule isn't a [HarmfulLinkAutoModerationRule]. - */ - override suspend fun asAutoModerationRule(): HarmfulLinkAutoModerationRule = - super.asAutoModerationRule() as HarmfulLinkAutoModerationRule - - override fun withStrategy(strategy: EntitySupplyStrategy<*>): HarmfulLinkAutoModerationRuleBehavior -} - -internal fun HarmfulLinkAutoModerationRuleBehavior( - guildId: Snowflake, - ruleId: Snowflake, - kord: Kord, - supplier: EntitySupplier = kord.defaultSupplier, -): HarmfulLinkAutoModerationRuleBehavior = object : HarmfulLinkAutoModerationRuleBehavior { - override val guildId get() = guildId - override val id get() = ruleId - override val kord get() = kord - override val supplier get() = supplier - - override fun withStrategy(strategy: EntitySupplyStrategy<*>) = - HarmfulLinkAutoModerationRuleBehavior(guildId, ruleId, kord, strategy.supply(kord)) - - override fun equals(other: Any?) = autoModerationRuleEquals(other) - override fun hashCode() = autoModerationRuleHashCode() - override fun toString() = - "HarmfulLinkAutoModerationRuleBehavior(guildId=$guildId, id=$id, kord=$kord, supplier=$supplier)" -} - -/** - * Requests to edit this [HarmfulLinkAutoModerationRule] and returns the edited rule. - * - * This requires the [ManageGuild] permission. - * - * @throws RestRequestException if something went wrong during the request. - */ -public suspend inline fun HarmfulLinkAutoModerationRuleBehavior.edit( - builder: HarmfulLinkAutoModerationRuleModifyBuilder.() -> Unit, -): HarmfulLinkAutoModerationRule { - contract { callsInPlace(builder, EXACTLY_ONCE) } - val rule = kord.rest.autoModeration.modifyHarmfulLinkAutoModerationRule(guildId, ruleId = id, builder) - return HarmfulLinkAutoModerationRule(AutoModerationRuleData.from(rule), kord, supplier) -} - - /** The behavior of a [SpamAutoModerationRule]. */ public interface SpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 499196ea42b6..27689d8c637c 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -108,7 +108,6 @@ internal fun AutoModerationRule( supplier: EntitySupplier = kord.defaultSupplier, ): AutoModerationRule = when (data.triggerType) { Keyword -> KeywordAutoModerationRule(data, kord, supplier) - HarmfulLink -> HarmfulLinkAutoModerationRule(data, kord, supplier) Spam -> SpamAutoModerationRule(data, kord, supplier) KeywordPreset -> KeywordPresetAutoModerationRule(data, kord, supplier) MentionSpam -> MentionSpamAutoModerationRule(data, kord, supplier) @@ -138,20 +137,6 @@ public class KeywordAutoModerationRule(data: AutoModerationRuleData, kord: Kord, override fun toString(): String = "KeywordAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" } -/** An [AutoModerationRule] with trigger type [HarmfulLink]. */ -public class HarmfulLinkAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : - AutoModerationRule(data, kord, supplier, expectedTriggerType = HarmfulLink), - HarmfulLinkAutoModerationRuleBehavior { - - override suspend fun asAutoModerationRuleOrNull(): HarmfulLinkAutoModerationRule = this - override suspend fun asAutoModerationRule(): HarmfulLinkAutoModerationRule = this - - override fun withStrategy(strategy: EntitySupplyStrategy<*>): HarmfulLinkAutoModerationRule = - HarmfulLinkAutoModerationRule(data, kord, strategy.supply(kord)) - - override fun toString(): String = "HarmfulLinkAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" -} - /** An [AutoModerationRule] with trigger type [Spam]. */ public class SpamAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = Spam), diff --git a/rest/api/rest.api b/rest/api/rest.api index ac67e053f728..10eaaebc3a0a 100644 --- a/rest/api/rest.api +++ b/rest/api/rest.api @@ -185,26 +185,6 @@ public final class dev/kord/rest/builder/automoderation/BlockMessageAutoModerati public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; } -public abstract interface class dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { - public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; -} - -public final class dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder$DefaultImpls { - public static fun getTriggerType (Ldev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder;)Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; -} - -public final class dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleCreateBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleCreateBuilder, dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder { - public fun (Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;)V - public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; - public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; -} - -public final class dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleModifyBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleModifyBuilder, dev/kord/rest/builder/automoderation/HarmfulLinkAutoModerationRuleBuilder { - public fun ()V - public fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$HarmfulLink; - public synthetic fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; -} - public abstract interface class dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { public abstract fun assignKeywords (Ljava/util/List;)V public abstract fun getKeywords ()Ljava/util/List; @@ -6706,7 +6686,6 @@ public final class dev/kord/rest/service/AutoModerationService : dev/kord/rest/s public fun (Ldev/kord/rest/request/RequestHandler;)V public final fun createAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun createAutoModerationRule$default (Ldev/kord/rest/service/AutoModerationService;Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AutoModerationRuleCreateRequest;Ljava/lang/String;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; - public final fun createHarmfulLinkAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun createKeywordAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun createKeywordPresetAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun createMentionSpamAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ljava/lang/String;Ldev/kord/common/entity/AutoModerationRuleEventType;ILkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; @@ -6717,7 +6696,6 @@ public final class dev/kord/rest/service/AutoModerationService : dev/kord/rest/s public final fun listAutoModerationRulesForGuild (Ldev/kord/common/entity/Snowflake;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun modifyAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest;Ljava/lang/String;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public static synthetic fun modifyAutoModerationRule$default (Ldev/kord/rest/service/AutoModerationService;Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Ldev/kord/rest/json/request/AutoModerationRuleModifyRequest;Ljava/lang/String;Lkotlin/coroutines/Continuation;ILjava/lang/Object;)Ljava/lang/Object; - public final fun modifyHarmfulLinkAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun modifyKeywordAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun modifyKeywordPresetAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; public final fun modifyMentionSpamAutoModerationRule (Ldev/kord/common/entity/Snowflake;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;Lkotlin/coroutines/Continuation;)Ljava/lang/Object; diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index 2d68e4ec5b04..1c558c84bf69 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -189,13 +189,6 @@ public fun KeywordAutoModerationRuleBuilder.anywhereKeyword(keyword: String) { } -/** An [AutoModerationRuleBuilder] for building rules with trigger type [HarmfulLink]. */ -@KordDsl -public sealed interface HarmfulLinkAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { - override val triggerType: HarmfulLink get() = HarmfulLink -} - - /** An [AutoModerationRuleBuilder] for building rules with trigger type [Spam]. */ @KordDsl public sealed interface SpamAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt index 9eb00d48db4b..dd30598feb7e 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt @@ -76,13 +76,6 @@ public class KeywordAutoModerationRuleCreateBuilder( DiscordAutoModerationRuleTriggerMetadata(keywordFilter = keywords.toList().optional()).optional() } -/** A [HarmfulLinkAutoModerationRuleBuilder] for building [AutoModerationRuleCreateRequest]s. */ -@KordDsl -public class HarmfulLinkAutoModerationRuleCreateBuilder( - name: String, - eventType: AutoModerationRuleEventType, -) : AutoModerationRuleCreateBuilder(name, eventType), HarmfulLinkAutoModerationRuleBuilder - /** A [SpamAutoModerationRuleBuilder] for building [AutoModerationRuleCreateRequest]s. */ @KordDsl public class SpamAutoModerationRuleCreateBuilder( diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt index ce49d008e2f1..fd49aa83dda1 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt @@ -89,13 +89,6 @@ public class KeywordAutoModerationRuleModifyBuilder : _keywords.map { DiscordAutoModerationRuleTriggerMetadata(keywordFilter = it.toList().optional()) } } -/** A [HarmfulLinkAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */ -@Suppress("CanSealedSubClassBeObject") // has state in super class -@KordDsl -public class HarmfulLinkAutoModerationRuleModifyBuilder : - AutoModerationRuleModifyBuilder(), - HarmfulLinkAutoModerationRuleBuilder - /** A [SpamAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */ @Suppress("CanSealedSubClassBeObject") // has state in super class @KordDsl diff --git a/rest/src/main/kotlin/service/AutoModerationService.kt b/rest/src/main/kotlin/service/AutoModerationService.kt index 1f0cde427c72..5b0840f91d6f 100644 --- a/rest/src/main/kotlin/service/AutoModerationService.kt +++ b/rest/src/main/kotlin/service/AutoModerationService.kt @@ -46,17 +46,6 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService return createAutoModerationRule(guildId, request.toRequest(), request.reason) } - public suspend inline fun createHarmfulLinkAutoModerationRule( - guildId: Snowflake, - name: String, - eventType: AutoModerationRuleEventType, - builder: HarmfulLinkAutoModerationRuleCreateBuilder.() -> Unit, - ): DiscordAutoModerationRule { - contract { callsInPlace(builder, EXACTLY_ONCE) } - val request = HarmfulLinkAutoModerationRuleCreateBuilder(name, eventType).apply(builder) - return createAutoModerationRule(guildId, request.toRequest(), request.reason) - } - public suspend inline fun createSpamAutoModerationRule( guildId: Snowflake, name: String, @@ -123,16 +112,6 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) } - public suspend inline fun modifyHarmfulLinkAutoModerationRule( - guildId: Snowflake, - ruleId: Snowflake, - builder: HarmfulLinkAutoModerationRuleModifyBuilder.() -> Unit, - ): DiscordAutoModerationRule { - contract { callsInPlace(builder, EXACTLY_ONCE) } - val request = HarmfulLinkAutoModerationRuleModifyBuilder().apply(builder) - return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) - } - public suspend inline fun modifySpamAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, From b9ca8c6984377ce322c21702597545e2ace56aec Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 28 Aug 2022 15:38:01 +0200 Subject: [PATCH 49/57] `@KordExperimental` for `Spam` and `MentionSpam` trigger types --- .../src/main/kotlin/entity/AutoModeration.kt | 15 +++++++++++-- core/src/main/kotlin/Unsafe.kt | 2 ++ .../src/main/kotlin/behavior/GuildBehavior.kt | 8 +++++++ .../AutoModerationRuleBehavior.kt | 21 +++++++++++++++++-- .../automoderation/AutoModerationRule.kt | 15 +++++++++++-- .../AutoModerationRuleBuilder.kt | 15 +++++++++++-- .../AutoModerationRuleCreateBuilder.kt | 17 +++++++++++++-- .../AutoModerationRuleModifyBuilder.kt | 17 +++++++++++++-- .../kotlin/service/AutoModerationService.kt | 5 +++++ 9 files changed, 103 insertions(+), 12 deletions(-) diff --git a/common/src/main/kotlin/entity/AutoModeration.kt b/common/src/main/kotlin/entity/AutoModeration.kt index da1c068c5490..c539c0f51e29 100644 --- a/common/src/main/kotlin/entity/AutoModeration.kt +++ b/common/src/main/kotlin/entity/AutoModeration.kt @@ -1,5 +1,6 @@ package dev.kord.common.entity +import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.AutoModerationRuleTriggerType.Keyword import dev.kord.common.entity.Permission.ModerateMembers import dev.kord.common.entity.optional.Optional @@ -52,13 +53,23 @@ public sealed class AutoModerationRuleTriggerType(public val value: Int) { /** Check if content contains words from a user defined list of keywords. */ public object Keyword : AutoModerationRuleTriggerType(1) - /** Check if content represents generic spam. */ + /** + * Check if content represents generic spam. + * + * This [trigger type][AutoModerationRuleTriggerType] is not yet released, so it cannot be used in most servers. + */ + @KordExperimental public object Spam : AutoModerationRuleTriggerType(3) /** Check if content contains words from internal pre-defined wordsets. */ public object KeywordPreset : AutoModerationRuleTriggerType(4) - /** Check if content contains more mentions than allowed. */ + /** + * Check if content contains more mentions than allowed. + * + * This [trigger type][AutoModerationRuleTriggerType] is not yet released, so it cannot be used in most servers. + */ + @KordExperimental public object MentionSpam : AutoModerationRuleTriggerType(5) diff --git a/core/src/main/kotlin/Unsafe.kt b/core/src/main/kotlin/Unsafe.kt index 162198ab85e2..43a04ebc6ba7 100644 --- a/core/src/main/kotlin/Unsafe.kt +++ b/core/src/main/kotlin/Unsafe.kt @@ -34,6 +34,7 @@ public class Unsafe(private val kord: Kord) { public fun keywordAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): KeywordAutoModerationRuleBehavior = KeywordAutoModerationRuleBehavior(guildId, ruleId, kord) + @KordExperimental public fun spamAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): SpamAutoModerationRuleBehavior = SpamAutoModerationRuleBehavior(guildId, ruleId, kord) @@ -42,6 +43,7 @@ public class Unsafe(private val kord: Kord) { ruleId: Snowflake, ): KeywordPresetAutoModerationRuleBehavior = KeywordPresetAutoModerationRuleBehavior(guildId, ruleId, kord) + @KordExperimental public fun mentionSpamAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, diff --git a/core/src/main/kotlin/behavior/GuildBehavior.kt b/core/src/main/kotlin/behavior/GuildBehavior.kt index 891630dfd050..7ee535aa6974 100644 --- a/core/src/main/kotlin/behavior/GuildBehavior.kt +++ b/core/src/main/kotlin/behavior/GuildBehavior.kt @@ -5,6 +5,8 @@ import dev.kord.common.annotation.DeprecatedSinceKord import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.* import dev.kord.common.entity.AutoModerationRuleEventType.MessageSend +import dev.kord.common.entity.AutoModerationRuleTriggerType.MentionSpam +import dev.kord.common.entity.AutoModerationRuleTriggerType.Spam import dev.kord.common.entity.Permission.ManageGuild import dev.kord.common.entity.optional.Optional import dev.kord.common.entity.optional.unwrap @@ -1133,11 +1135,14 @@ public suspend inline fun GuildBehavior.createKeywordAutoModerationRule( * * This requires the [ManageGuild] permission. * + * The [Spam] trigger type is not yet released, so it cannot be used in most servers. + * * @param name the rule name. * @param eventType the rule [event type][AutoModerationRuleEventType]. * * @throws RestRequestException if something went wrong during the request. */ +@KordExperimental public suspend inline fun GuildBehavior.createSpamAutoModerationRule( name: String, eventType: AutoModerationRuleEventType = MessageSend, @@ -1173,12 +1178,15 @@ public suspend inline fun GuildBehavior.createKeywordPresetAutoModerationRule( * * This requires the [ManageGuild] permission. * + * The [MentionSpam] trigger type is not yet released, so it cannot be used in most servers. + * * @param name the rule name. * @param eventType the rule [event type][AutoModerationRuleEventType]. * @param mentionLimit total number of mentions (role & user) allowed per message (maximum of 50). * * @throws RestRequestException if something went wrong during the request. */ +@KordExperimental public suspend inline fun GuildBehavior.createMentionSpamAutoModerationRule( name: String, eventType: AutoModerationRuleEventType = MessageSend, diff --git a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt index e77016aed01e..005112b4386a 100644 --- a/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt +++ b/core/src/main/kotlin/behavior/automoderation/AutoModerationRuleBehavior.kt @@ -1,5 +1,6 @@ package dev.kord.core.behavior.automoderation +import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.AutoModerationRuleTriggerType import dev.kord.common.entity.AutoModerationRuleTriggerType.* import dev.kord.common.entity.Permission.ManageGuild @@ -216,7 +217,12 @@ public suspend inline fun KeywordAutoModerationRuleBehavior.edit( } -/** The behavior of a [SpamAutoModerationRule]. */ +/** + * The behavior of a [SpamAutoModerationRule]. + * + * The [Spam] trigger type is not yet released, so it cannot be used in most servers. + */ +@KordExperimental public interface SpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { override val triggerType: Spam get() = Spam @@ -272,8 +278,11 @@ internal fun SpamAutoModerationRuleBehavior( * * This requires the [ManageGuild] permission. * + * The [Spam] trigger type is not yet released, so it cannot be used in most servers. + * * @throws RestRequestException if something went wrong during the request. */ +@KordExperimental public suspend inline fun SpamAutoModerationRuleBehavior.edit( builder: SpamAutoModerationRuleModifyBuilder.() -> Unit, ): SpamAutoModerationRule { @@ -350,7 +359,12 @@ public suspend inline fun KeywordPresetAutoModerationRuleBehavior.edit( } -/** The behavior of a [MentionSpamAutoModerationRule]. */ +/** + * The behavior of a [MentionSpamAutoModerationRule]. + * + * The [MentionSpam] trigger type is not yet released, so it cannot be used in most servers. + */ +@KordExperimental public interface MentionSpamAutoModerationRuleBehavior : TypedAutoModerationRuleBehavior { override val triggerType: MentionSpam get() = MentionSpam @@ -406,8 +420,11 @@ internal fun MentionSpamAutoModerationRuleBehavior( * * This requires the [ManageGuild] permission. * + * The [MentionSpam] trigger type is not yet released, so it cannot be used in most servers. + * * @throws RestRequestException if something went wrong during the request. */ +@KordExperimental public suspend inline fun MentionSpamAutoModerationRuleBehavior.edit( builder: MentionSpamAutoModerationRuleModifyBuilder.() -> Unit, ): MentionSpamAutoModerationRule { diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index 27689d8c637c..dfa0afd8ddc5 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -1,5 +1,6 @@ package dev.kord.core.entity.automoderation +import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.AutoModerationRuleEventType import dev.kord.common.entity.AutoModerationRuleKeywordPresetType import dev.kord.common.entity.AutoModerationRuleTriggerType @@ -137,7 +138,12 @@ public class KeywordAutoModerationRule(data: AutoModerationRuleData, kord: Kord, override fun toString(): String = "KeywordAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" } -/** An [AutoModerationRule] with trigger type [Spam]. */ +/** + * An [AutoModerationRule] with trigger type [Spam]. + * + * The [Spam] trigger type is not yet released, so it cannot be used in most servers. + */ +@KordExperimental public class SpamAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = Spam), SpamAutoModerationRuleBehavior { @@ -175,7 +181,12 @@ public class KeywordPresetAutoModerationRule(data: AutoModerationRuleData, kord: override fun toString(): String = "KeywordPresetAutoModerationRule(data=$data, kord=$kord, supplier=$supplier)" } -/** An [AutoModerationRule] with trigger type [MentionSpam]. */ +/** + * An [AutoModerationRule] with trigger type [MentionSpam]. + * + * The [MentionSpam] trigger type is not yet released, so it cannot be used in most servers. + */ +@KordExperimental public class MentionSpamAutoModerationRule(data: AutoModerationRuleData, kord: Kord, supplier: EntitySupplier) : AutoModerationRule(data, kord, supplier, expectedTriggerType = MentionSpam), MentionSpamAutoModerationRuleBehavior { diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index 1c558c84bf69..b549d59a114a 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -1,6 +1,7 @@ package dev.kord.rest.builder.automoderation import dev.kord.common.annotation.KordDsl +import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.AutoModerationActionType.* import dev.kord.common.entity.AutoModerationRuleEventType import dev.kord.common.entity.AutoModerationRuleKeywordPresetType @@ -189,8 +190,13 @@ public fun KeywordAutoModerationRuleBuilder.anywhereKeyword(keyword: String) { } -/** An [AutoModerationRuleBuilder] for building rules with trigger type [Spam]. */ +/** + * An [AutoModerationRuleBuilder] for building rules with trigger type [Spam]. + * + * The [Spam] trigger type is not yet released, so it cannot be used in most servers. + */ @KordDsl +@KordExperimental public sealed interface SpamAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { override val triggerType: Spam get() = Spam } @@ -234,8 +240,13 @@ public fun KeywordPresetAutoModerationRuleBuilder.allowKeyword(keyword: String) } -/** An [AutoModerationRuleBuilder] for building rules with trigger type [MentionSpam]. */ +/** + * An [AutoModerationRuleBuilder] for building rules with trigger type [MentionSpam]. + * + * The [MentionSpam] trigger type is not yet released, so it cannot be used in most servers. + */ @KordDsl +@KordExperimental public sealed interface MentionSpamAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { override val triggerType: MentionSpam get() = MentionSpam diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt index dd30598feb7e..c1a1133fffd0 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleCreateBuilder.kt @@ -1,8 +1,11 @@ package dev.kord.rest.builder.automoderation import dev.kord.common.annotation.KordDsl +import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.AutoModerationRuleEventType import dev.kord.common.entity.AutoModerationRuleKeywordPresetType +import dev.kord.common.entity.AutoModerationRuleTriggerType.MentionSpam +import dev.kord.common.entity.AutoModerationRuleTriggerType.Spam import dev.kord.common.entity.DiscordAutoModerationRuleTriggerMetadata import dev.kord.common.entity.Snowflake import dev.kord.common.entity.optional.* @@ -76,8 +79,13 @@ public class KeywordAutoModerationRuleCreateBuilder( DiscordAutoModerationRuleTriggerMetadata(keywordFilter = keywords.toList().optional()).optional() } -/** A [SpamAutoModerationRuleBuilder] for building [AutoModerationRuleCreateRequest]s. */ +/** + * A [SpamAutoModerationRuleBuilder] for building [AutoModerationRuleCreateRequest]s. + * + * The [Spam] trigger type is not yet released, so it cannot be used in most servers. + */ @KordDsl +@KordExperimental public class SpamAutoModerationRuleCreateBuilder( name: String, eventType: AutoModerationRuleEventType, @@ -107,8 +115,13 @@ public class KeywordPresetAutoModerationRuleCreateBuilder( ).optional() } -/** A [MentionSpamAutoModerationRuleBuilder] for building [AutoModerationRuleCreateRequest]s. */ +/** + * A [MentionSpamAutoModerationRuleBuilder] for building [AutoModerationRuleCreateRequest]s. + * + * The [MentionSpam] trigger type is not yet released, so it cannot be used in most servers. + */ @KordDsl +@KordExperimental public class MentionSpamAutoModerationRuleCreateBuilder( name: String, eventType: AutoModerationRuleEventType, diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt index fd49aa83dda1..3fe360f24f66 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleModifyBuilder.kt @@ -1,7 +1,10 @@ package dev.kord.rest.builder.automoderation import dev.kord.common.annotation.KordDsl +import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.* +import dev.kord.common.entity.AutoModerationRuleTriggerType.MentionSpam +import dev.kord.common.entity.AutoModerationRuleTriggerType.Spam import dev.kord.common.entity.optional.* import dev.kord.common.entity.optional.delegate.delegate import dev.kord.rest.builder.AuditRequestBuilder @@ -89,9 +92,14 @@ public class KeywordAutoModerationRuleModifyBuilder : _keywords.map { DiscordAutoModerationRuleTriggerMetadata(keywordFilter = it.toList().optional()) } } -/** A [SpamAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */ +/** + * A [SpamAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. + * + * The [Spam] trigger type is not yet released, so it cannot be used in most servers. + */ @Suppress("CanSealedSubClassBeObject") // has state in super class @KordDsl +@KordExperimental public class SpamAutoModerationRuleModifyBuilder : AutoModerationRuleModifyBuilder(), SpamAutoModerationRuleBuilder @@ -128,8 +136,13 @@ public class KeywordPresetAutoModerationRuleModifyBuilder : } } -/** A [MentionSpamAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. */ +/** + * A [MentionSpamAutoModerationRuleBuilder] for building [AutoModerationRuleModifyRequest]s. + * + * The [MentionSpam] trigger type is not yet released, so it cannot be used in most servers. + */ @KordDsl +@KordExperimental public class MentionSpamAutoModerationRuleModifyBuilder : AutoModerationRuleModifyBuilder(), MentionSpamAutoModerationRuleBuilder { diff --git a/rest/src/main/kotlin/service/AutoModerationService.kt b/rest/src/main/kotlin/service/AutoModerationService.kt index 5b0840f91d6f..48405e04a2b4 100644 --- a/rest/src/main/kotlin/service/AutoModerationService.kt +++ b/rest/src/main/kotlin/service/AutoModerationService.kt @@ -1,5 +1,6 @@ package dev.kord.rest.service +import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.AutoModerationRuleEventType import dev.kord.common.entity.DiscordAutoModerationRule import dev.kord.common.entity.Snowflake @@ -46,6 +47,7 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService return createAutoModerationRule(guildId, request.toRequest(), request.reason) } + @KordExperimental public suspend inline fun createSpamAutoModerationRule( guildId: Snowflake, name: String, @@ -68,6 +70,7 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService return createAutoModerationRule(guildId, request.toRequest(), request.reason) } + @KordExperimental public suspend inline fun createMentionSpamAutoModerationRule( guildId: Snowflake, name: String, @@ -112,6 +115,7 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) } + @KordExperimental public suspend inline fun modifySpamAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, @@ -132,6 +136,7 @@ public class AutoModerationService(requestHandler: RequestHandler) : RestService return modifyAutoModerationRule(guildId, ruleId, request.toRequest(), request.reason) } + @KordExperimental public suspend inline fun modifyMentionSpamAutoModerationRule( guildId: Snowflake, ruleId: Snowflake, From 895d601b82f2505ae98a826d7a31cf1079fb6d9b Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 28 Aug 2022 16:02:06 +0200 Subject: [PATCH 50/57] Allow `Timeout` actions for `MentionSpam` rules --- .../src/main/kotlin/entity/AutoModeration.kt | 5 ++- rest/api/rest.api | 11 +++-- .../AutoModerationRuleBuilder.kt | 41 +++++++++++-------- 3 files changed, 33 insertions(+), 24 deletions(-) diff --git a/common/src/main/kotlin/entity/AutoModeration.kt b/common/src/main/kotlin/entity/AutoModeration.kt index c539c0f51e29..084e0ea840c2 100644 --- a/common/src/main/kotlin/entity/AutoModeration.kt +++ b/common/src/main/kotlin/entity/AutoModeration.kt @@ -2,6 +2,7 @@ package dev.kord.common.entity import dev.kord.common.annotation.KordExperimental import dev.kord.common.entity.AutoModerationRuleTriggerType.Keyword +import dev.kord.common.entity.AutoModerationRuleTriggerType.MentionSpam import dev.kord.common.entity.Permission.ModerateMembers import dev.kord.common.entity.optional.Optional import dev.kord.common.entity.optional.OptionalInt @@ -198,8 +199,8 @@ public sealed class AutoModerationActionType(public val value: Int) { /** * Timeout user for a specified duration. * - * A [Timeout] action can only be setup for [Keyword] rules. The [ModerateMembers] permission is required to use the - * [Timeout] action type. + * A [Timeout] action can only be set up for [Keyword] and [MentionSpam] rules. The [ModerateMembers] permission is + * required to use the [Timeout] action type. */ public object Timeout : AutoModerationActionType(3) diff --git a/rest/api/rest.api b/rest/api/rest.api index 10eaaebc3a0a..723d3aff1aab 100644 --- a/rest/api/rest.api +++ b/rest/api/rest.api @@ -128,8 +128,8 @@ public final class dev/kord/rest/builder/automoderation/AutoModerationRuleBuilde public static final fun sendAlertMessage (Ldev/kord/rest/builder/automoderation/AutoModerationRuleBuilder;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;)V public static synthetic fun sendAlertMessage$default (Ldev/kord/rest/builder/automoderation/AutoModerationRuleBuilder;Ldev/kord/common/entity/Snowflake;Lkotlin/jvm/functions/Function1;ILjava/lang/Object;)V public static final fun suffixKeyword (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;Ljava/lang/String;)V - public static final fun timeout-8Mi8wO0 (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;JLkotlin/jvm/functions/Function1;)V - public static synthetic fun timeout-8Mi8wO0$default (Ldev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder;JLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V + public static final fun timeout-8Mi8wO0 (Ldev/kord/rest/builder/automoderation/TimeoutAutoModerationRuleBuilder;JLkotlin/jvm/functions/Function1;)V + public static synthetic fun timeout-8Mi8wO0$default (Ldev/kord/rest/builder/automoderation/TimeoutAutoModerationRuleBuilder;JLkotlin/jvm/functions/Function1;ILjava/lang/Object;)V } public abstract class dev/kord/rest/builder/automoderation/AutoModerationRuleCreateBuilder : dev/kord/rest/builder/AuditRequestBuilder, dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { @@ -185,7 +185,7 @@ public final class dev/kord/rest/builder/automoderation/BlockMessageAutoModerati public synthetic fun getType ()Ldev/kord/common/entity/AutoModerationActionType; } -public abstract interface class dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { +public abstract interface class dev/kord/rest/builder/automoderation/KeywordAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TimeoutAutoModerationRuleBuilder { public abstract fun assignKeywords (Ljava/util/List;)V public abstract fun getKeywords ()Ljava/util/List; public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$Keyword; @@ -249,7 +249,7 @@ public final class dev/kord/rest/builder/automoderation/KeywordPresetAutoModerat public fun setPresets (Ljava/util/List;)V } -public abstract interface class dev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { +public abstract interface class dev/kord/rest/builder/automoderation/MentionSpamAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TimeoutAutoModerationRuleBuilder { public abstract fun assignMentionLimit (I)V public abstract fun getMentionLimit ()Ljava/lang/Integer; public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType$MentionSpam; @@ -316,6 +316,9 @@ public final class dev/kord/rest/builder/automoderation/TimeoutAutoModerationAct public final fun setDuration-LRDsOJo (J)V } +public abstract interface class dev/kord/rest/builder/automoderation/TimeoutAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder { +} + public abstract interface class dev/kord/rest/builder/automoderation/TypedAutoModerationRuleBuilder : dev/kord/rest/builder/automoderation/AutoModerationRuleBuilder { public abstract fun getTriggerType ()Ldev/kord/common/entity/AutoModerationRuleTriggerType; } diff --git a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt index b549d59a114a..18711b3f0934 100644 --- a/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt +++ b/rest/src/main/kotlin/builder/automoderation/AutoModerationRuleBuilder.kt @@ -110,9 +110,30 @@ public sealed interface TypedAutoModerationRuleBuilder : AutoModerationRuleBuild } +/** An [AutoModerationRuleBuilder] for building rules that can have a [Timeout] action. */ +@KordDsl +public sealed interface TimeoutAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder + +/** + * Add a [Timeout] action which will execute whenever the rule is triggered. + * + * The [ModerateMembers] permission is required to use this action. + * + * @param duration the timeout duration (maximum of 2419200 seconds (4 weeks)). + */ +public inline fun TimeoutAutoModerationRuleBuilder.timeout( + duration: Duration, + builder: TimeoutAutoModerationActionBuilder.() -> Unit = {}, +) { + contract { callsInPlace(builder, EXACTLY_ONCE) } + val action = TimeoutAutoModerationActionBuilder(duration).apply(builder) + actions?.add(action) ?: assignActions(mutableListOf(action)) +} + + /** An [AutoModerationRuleBuilder] for building rules with trigger type [Keyword]. */ @KordDsl -public sealed interface KeywordAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { +public sealed interface KeywordAutoModerationRuleBuilder : TimeoutAutoModerationRuleBuilder { override val triggerType: Keyword get() = Keyword @@ -129,22 +150,6 @@ public sealed interface KeywordAutoModerationRuleBuilder : TypedAutoModerationRu public fun assignKeywords(keywords: MutableList) } -/** - * Add a [Timeout] action which will execute whenever the rule is triggered. - * - * The [ModerateMembers] permission is required to use this action. - * - * @param duration the timeout duration (maximum of 2419200 seconds (4 weeks)). - */ -public inline fun KeywordAutoModerationRuleBuilder.timeout( - duration: Duration, - builder: TimeoutAutoModerationActionBuilder.() -> Unit = {}, -) { - contract { callsInPlace(builder, EXACTLY_ONCE) } - val action = TimeoutAutoModerationActionBuilder(duration).apply(builder) - actions?.add(action) ?: assignActions(mutableListOf(action)) -} - /** * Add a [keyword] to [keywords][KeywordAutoModerationRuleBuilder.keywords]. * @@ -247,7 +252,7 @@ public fun KeywordPresetAutoModerationRuleBuilder.allowKeyword(keyword: String) */ @KordDsl @KordExperimental -public sealed interface MentionSpamAutoModerationRuleBuilder : TypedAutoModerationRuleBuilder { +public sealed interface MentionSpamAutoModerationRuleBuilder : TimeoutAutoModerationRuleBuilder { override val triggerType: MentionSpam get() = MentionSpam From c1e721327cd953aab916376a966ff781f6cae640 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 28 Aug 2022 17:02:27 +0200 Subject: [PATCH 51/57] KDoc for `AutoModerationRuleKeywordPresetType` --- common/src/main/kotlin/entity/AutoModeration.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/common/src/main/kotlin/entity/AutoModeration.kt b/common/src/main/kotlin/entity/AutoModeration.kt index 084e0ea840c2..e661994d6c14 100644 --- a/common/src/main/kotlin/entity/AutoModeration.kt +++ b/common/src/main/kotlin/entity/AutoModeration.kt @@ -102,6 +102,7 @@ public data class DiscordAutoModerationRuleTriggerMetadata( val mentionTotalLimit: OptionalInt = OptionalInt.Missing, ) +/** An internally pre-defined wordset which will be searched for in content. */ @Serializable(with = AutoModerationRuleKeywordPresetType.Serializer::class) public sealed class AutoModerationRuleKeywordPresetType(public val value: Int) { From 4a58bbeb5b55313316895bb9d8aee1f61a0631fb Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 28 Aug 2022 17:05:59 +0200 Subject: [PATCH 52/57] KDoc for `AutoModerationActionType` --- common/src/main/kotlin/entity/AutoModeration.kt | 1 + 1 file changed, 1 insertion(+) diff --git a/common/src/main/kotlin/entity/AutoModeration.kt b/common/src/main/kotlin/entity/AutoModeration.kt index e661994d6c14..a8a56ece30f4 100644 --- a/common/src/main/kotlin/entity/AutoModeration.kt +++ b/common/src/main/kotlin/entity/AutoModeration.kt @@ -179,6 +179,7 @@ public data class DiscordAutoModerationAction( val metadata: Optional = Optional.Missing(), ) +/** The type of action. */ @Serializable(with = AutoModerationActionType.Serializer::class) public sealed class AutoModerationActionType(public val value: Int) { From c9cb627741e20f0656bcb84d5ca16e20b1d54d08 Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 28 Aug 2022 21:32:52 +0200 Subject: [PATCH 53/57] Add missing removes in `removeKordData()` --- core/src/main/kotlin/cache/DataCacheExtensions.kt | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/core/src/main/kotlin/cache/DataCacheExtensions.kt b/core/src/main/kotlin/cache/DataCacheExtensions.kt index 94abbf81e5c6..0ebc3deba6a5 100644 --- a/core/src/main/kotlin/cache/DataCacheExtensions.kt +++ b/core/src/main/kotlin/cache/DataCacheExtensions.kt @@ -35,11 +35,16 @@ internal suspend fun DataCache.removeKordData() { query().remove() query().remove() query().remove() + query().remove() query().remove() query().remove() query().remove() query().remove() query().remove() + query().remove() + query().remove() + query().remove() + query().remove() query().remove() } From b1edada2589810f7868a8489db42030db69cabbd Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 28 Aug 2022 21:33:25 +0200 Subject: [PATCH 54/57] Add `KordCacheBuilder.autoModerationRules` --- core/api/core.api | 1 + core/src/main/kotlin/cache/KordCache.kt | 4 ++++ 2 files changed, 5 insertions(+) diff --git a/core/api/core.api b/core/api/core.api index 668972da33fe..0b8bf60fb232 100644 --- a/core/api/core.api +++ b/core/api/core.api @@ -2205,6 +2205,7 @@ public final class dev/kord/core/cache/DataCacheView : dev/kord/cache/api/DataCa public final class dev/kord/core/cache/KordCacheBuilder { public fun ()V + public final fun autoModerationRules (Lkotlin/jvm/functions/Function2;)V public final fun build ()Ldev/kord/cache/api/DataCache; public final fun channels (Lkotlin/jvm/functions/Function2;)V public final fun disableAll ()V diff --git a/core/src/main/kotlin/cache/KordCache.kt b/core/src/main/kotlin/cache/KordCache.kt index 9bba199257c4..c886b88d1713 100644 --- a/core/src/main/kotlin/cache/KordCache.kt +++ b/core/src/main/kotlin/cache/KordCache.kt @@ -124,6 +124,10 @@ public class KordCacheBuilder { */ public fun voiceState(generator: Generator): Unit = forDescription(VoiceStateData.description, generator) + /** Configures the caching for [AutoModerationRuleData]. */ + public fun autoModerationRules(generator: Generator): Unit = + forDescription(AutoModerationRuleData.description, generator) + public fun build(): DataCache = DelegatingDataCache(EntrySupplier.invoke { cache, description -> val generator = descriptionGenerators[description] ?: defaultGenerator generator(cache, description) From c7e548e221079ac2766ba1bfb24a8897b1c36c9a Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Sun, 28 Aug 2022 22:30:31 +0200 Subject: [PATCH 55/57] Add KDoc for automod methods in `EntitySupplier` --- .../main/kotlin/supplier/EntitySupplier.kt | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/core/src/main/kotlin/supplier/EntitySupplier.kt b/core/src/main/kotlin/supplier/EntitySupplier.kt index 8cf91ef70d44..153ad6190d75 100644 --- a/core/src/main/kotlin/supplier/EntitySupplier.kt +++ b/core/src/main/kotlin/supplier/EntitySupplier.kt @@ -1,6 +1,7 @@ package dev.kord.core.supplier import dev.kord.common.entity.ChannelType.Unknown +import dev.kord.common.entity.Permission.ManageGuild import dev.kord.common.entity.Snowflake import dev.kord.common.exception.RequestException import dev.kord.core.entity.* @@ -611,8 +612,33 @@ public interface EntitySupplier { public fun getGuildStickers(guildId: Snowflake): Flow + /** + * Requests to get all [AutoModerationRule]s currently configured for the [Guild] with the given [guildId]. + * + * This requires the [ManageGuild] permission. + * + * The returned flow is lazily executed, any [RequestException] will be thrown on + * [terminal operators](https://kotlinlang.org/docs/reference/coroutines/flow.html#terminal-flow-operators) instead. + */ public fun getAutoModerationRules(guildId: Snowflake): Flow + + /** + * Requests an [AutoModerationRule] by its [id][ruleId]. Returns `null` if it wasn't found. + * + * This requires the [ManageGuild] permission. + * + * @throws RequestException if something went wrong during the request. + */ public suspend fun getAutoModerationRuleOrNull(guildId: Snowflake, ruleId: Snowflake): AutoModerationRule? + + /** + * Requests an [AutoModerationRule] by its [id][ruleId]. + * + * This requires the [ManageGuild] permission. + * + * @throws RequestException if something went wrong during the request. + * @throws EntityNotFoundException if the [AutoModerationRule] wasn't found. + */ public suspend fun getAutoModerationRule(guildId: Snowflake, ruleId: Snowflake): AutoModerationRule = getAutoModerationRuleOrNull(guildId, ruleId) ?: EntityNotFoundException.autoModerationRuleNotFound(guildId, ruleId) From 9af4780fabfc68179fa16e23e8b9c8caab4fc03b Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 29 Aug 2022 00:06:29 +0200 Subject: [PATCH 56/57] Adjust init blocks --- .../kotlin/entity/automoderation/AutoModerationAction.kt | 7 +++---- .../kotlin/entity/automoderation/AutoModerationRule.kt | 7 +++---- 2 files changed, 6 insertions(+), 8 deletions(-) diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt index 80898b65c940..29dfa2c9b740 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationAction.kt @@ -16,12 +16,11 @@ public sealed class AutoModerationAction( expectedActionType: AutoModerationActionType?, ) : KordObject { init { + val type = data.type if (expectedActionType == null) { - require(data.type is Unknown) { "Expected unknown action type but got ${data.type}" } + require(type is Unknown) { "Expected unknown action type but got $type" } } else { - require(data.type == expectedActionType) { - "Wrong action type, expected $expectedActionType but got ${data.type}" - } + require(type == expectedActionType) { "Wrong action type, expected $expectedActionType but got $type" } } } diff --git a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt index dfa0afd8ddc5..d4288fedd5d2 100644 --- a/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt +++ b/core/src/main/kotlin/entity/automoderation/AutoModerationRule.kt @@ -38,12 +38,11 @@ public sealed class AutoModerationRule( ) : TypedAutoModerationRuleBehavior { init { + val type = data.triggerType if (expectedTriggerType == null) { - require(data.triggerType is Unknown) { "Expected unknown trigger type but got ${data.triggerType}" } + require(type is Unknown) { "Expected unknown trigger type but got $type" } } else { - require(data.triggerType == expectedTriggerType) { - "Wrong trigger type, expected $expectedTriggerType but got ${data.triggerType}" - } + require(type == expectedTriggerType) { "Wrong trigger type, expected $expectedTriggerType but got $type" } } } From 2ee9016e9bf954b751b17e6be20bfd9a39d7c26b Mon Sep 17 00:00:00 2001 From: Lukellmann Date: Mon, 29 Aug 2022 13:47:23 +0200 Subject: [PATCH 57/57] Rename user to member in `AutoModerationActionExecutionEvent` --- core/api/core.api | 4 ++-- .../automoderation/AutoModerationActionExecutionEvent.kt | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/core/api/core.api b/core/api/core.api index 0b8bf60fb232..eecc4838f367 100644 --- a/core/api/core.api +++ b/core/api/core.api @@ -10681,14 +10681,14 @@ public final class dev/kord/core/event/automoderation/AutoModerationActionExecut public fun getKord ()Ldev/kord/core/Kord; public final fun getMatchedContent ()Ljava/lang/String; public final fun getMatchedKeyword ()Ljava/lang/String; + public final fun getMember ()Ldev/kord/core/behavior/MemberBehavior; + public final fun getMemberId ()Ldev/kord/common/entity/Snowflake; public final fun getMessage ()Ldev/kord/core/behavior/MessageBehavior; public final fun getMessageId ()Ldev/kord/common/entity/Snowflake; public fun getRule ()Ldev/kord/core/behavior/automoderation/TypedAutoModerationRuleBehavior; public fun getRuleId ()Ldev/kord/common/entity/Snowflake; public fun getShard ()I public fun getSupplier ()Ldev/kord/core/supplier/EntitySupplier; - public final fun getUser ()Ldev/kord/core/behavior/MemberBehavior; - public final fun getUserId ()Ldev/kord/common/entity/Snowflake; public fun toString ()Ljava/lang/String; public synthetic fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/entity/Strategizable; public fun withStrategy (Ldev/kord/core/supplier/EntitySupplyStrategy;)Ldev/kord/core/event/automoderation/AutoModerationActionExecutionEvent; diff --git a/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt b/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt index 971f0f243cfa..d8f5eb909890 100644 --- a/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt +++ b/core/src/main/kotlin/event/automoderation/AutoModerationActionExecutionEvent.kt @@ -48,10 +48,10 @@ public class AutoModerationActionExecutionEvent( get() = TypedAutoModerationRuleBehavior(guildId, ruleId, data.ruleTriggerType, kord) /** The ID of the [Member] which generated the content which triggered the rule. */ - public val userId: Snowflake get() = data.userId + public val memberId: Snowflake get() = data.userId /** The behavior of the [Member] which generated the content which triggered the rule. */ - public val user: MemberBehavior get() = MemberBehavior(guildId, id = userId, kord) + public val member: MemberBehavior get() = MemberBehavior(guildId, id = memberId, kord) /** The ID of the [GuildMessageChannel] in which user [content] was posted. */ public val channelId: Snowflake? get() = data.channelId.value