@neontechspace/fluxerly 1000.0.0-nightly.12

package/src/internal/guild-discovery.ts

@@ -0,0 +1,332 @@
+/**
+ * Guild discovery operations: Application, eligibility, categories and search.
+ * Invariant: Requests are validated locally and responses decoded completely, with timestamps checked by the shared grammar.
+ * Implements [SDK contracts: Delivery, requests and caches](/docs/SDK-CONTRACTS.md#delivery-requests-and-caches)
+ */
+import type {
+    DiscoveryApplication,
+    DiscoveryApplicationInput,
+    DiscoveryApplicationEdit,
+    DiscoveryCategory,
+    DiscoveryStatus,
+    DiscoveryCategoryCount,
+    DiscoveryGuild,
+    DiscoverySearchPage,
+    DiscoverySearchQuery,
+} from "#sdk/discovery"
+import type { GuildRequest } from "./guilds.js"
+import { InputValidationFailure, inputValidationFailure, unsupportedKeyFailure } from "#sdk/input-validation"
+import { identifier, record } from "./decode/primitives.js"
+import { nonNegativeInteger as integer } from "./decode/primitives.js"
+import { nullableTimestamp as nullableTime, timestamp } from "./decode/timestamp.js"
+
+const text = (value: unknown, min: number, max: number): value is string =>
+    typeof value === "string" && value.length >= min && value.length <= max
+const nullableText = (value: unknown): value is string | null => value === null || typeof value === "string"
+
+function application(value: unknown, guildId: string): DiscoveryApplication | undefined {
+    if (
+        !record(value) ||
+        value.guild_id !== guildId ||
+        !text(value.status, 1, 100) ||
+        typeof value.description !== "string" ||
+        !integer(value.category_type) ||
+        !nullableText(value.primary_language) ||
+        !Array.isArray(value.custom_tags) ||
+        !Array.from(value.custom_tags).every((tag) => typeof tag === "string") ||
+        !timestamp(value.applied_at) ||
+        !nullableTime(value.reviewed_at) ||
+        !nullableTime(value.removed_at) ||
+        !nullableText(value.review_reason) ||
+        !nullableText(value.removal_reason) ||
+        (value.guild_nsfw_level !== undefined && value.guild_nsfw_level !== null && !integer(value.guild_nsfw_level, 3))
+    )
+        return undefined
+    return Object.freeze({
+        guildId,
+        status: value.status,
+        description: value.description,
+        categoryId: value.category_type,
+        primaryLanguage: value.primary_language,
+        tags: Object.freeze([...value.custom_tags] as string[]),
+        appliedAt: value.applied_at,
+        reviewedAt: value.reviewed_at,
+        reviewReason: value.review_reason,
+        removedAt: value.removed_at,
+        removalReason: value.removal_reason,
+        ...(value.guild_nsfw_level === undefined ? {} : { guildNsfwLevel: value.guild_nsfw_level as number | null }),
+    })
+}
+
+export function discoveryStatus(guildId: string): GuildRequest<DiscoveryStatus> | InputValidationFailure {
+    if (!identifier(guildId)) return inputValidationFailure("guildId", "format", "Guild IDs must be decimal strings")
+    return {
+        guildId,
+        bucket: "guild:discovery:status",
+        path: `/guilds/${guildId}/discovery`,
+        method: "GET",
+        status: 200,
+        decode: (value) => {
+            if (!record(value) || typeof value.eligible !== "boolean" || !integer(value.min_member_count))
+                return undefined
+            const item = value.application === null ? null : application(value.application, guildId)
+            return item === undefined
+                ? undefined
+                : Object.freeze({ application: item, eligible: value.eligible, minMemberCount: value.min_member_count })
+        },
+    }
+}
+
+export function discoveryCategories(): GuildRequest<readonly DiscoveryCategory[]> {
+    return {
+        guildId: "discovery",
+        bucket: "discovery:categories",
+        path: "/discovery/categories",
+        method: "GET",
+        status: 200,
+        decode: (value) => {
+            if (!Array.isArray(value)) return undefined
+            const ids = new Set<number>(),
+                result: DiscoveryCategory[] = []
+            for (const entry of value) {
+                if (!record(entry) || !integer(entry.id) || !text(entry.name, 1, 200) || ids.has(entry.id))
+                    return undefined
+                ids.add(entry.id)
+                result.push(Object.freeze({ id: entry.id, name: entry.name }))
+            }
+            return Object.freeze(result)
+        },
+    }
+}
+
+function discoveryGuild(value: unknown): DiscoveryGuild | undefined {
+    if (
+        !record(value) ||
+        !identifier(value.id) ||
+        typeof value.name !== "string" ||
+        (value.icon !== undefined && !nullableText(value.icon)) ||
+        (value.banner !== undefined && !nullableText(value.banner)) ||
+        (value.description !== undefined && !nullableText(value.description)) ||
+        !integer(value.category_type, 8) ||
+        (value.primary_language !== undefined && !nullableText(value.primary_language)) ||
+        !Array.isArray(value.custom_tags) ||
+        !value.custom_tags.every((tag) => typeof tag === "string") ||
+        !integer(value.member_count) ||
+        !integer(value.online_count) ||
+        !Array.isArray(value.features) ||
+        !value.features.every((feature) => typeof feature === "string") ||
+        !integer(value.verification_level)
+    )
+        return undefined
+    return Object.freeze({
+        id: value.id,
+        name: value.name,
+        icon: value.icon ?? null,
+        banner: value.banner ?? null,
+        description: value.description ?? null,
+        categoryId: value.category_type,
+        primaryLanguage: value.primary_language ?? null,
+        tags: Object.freeze([...value.custom_tags] as string[]),
+        memberCount: value.member_count,
+        onlineCount: value.online_count,
+        features: Object.freeze([...value.features] as string[]),
+        verificationLevel: value.verification_level,
+    })
+}
+
+/** Build one volatile directory search page. Offset pagination has no snapshot or traversal guarantee */
+export function discoverySearch(
+    query?: DiscoverySearchQuery,
+): GuildRequest<DiscoverySearchPage> | InputValidationFailure {
+    if (query !== undefined && !record(query))
+        return inputValidationFailure("query", "type", "Discovery search query must be an object")
+    const input = query as DiscoverySearchQuery | undefined
+    const unsupported =
+        input === undefined
+            ? undefined
+            : unsupportedKeyFailure(
+                  input,
+                  ["query", "categoryId", "primaryLanguage", "tag", "sortBy", "limit", "offset"],
+                  "query",
+                  "the discovery search query",
+              )
+    if (unsupported) return unsupported
+    if (input?.query !== undefined && !text(input.query, 0, 100))
+        return inputValidationFailure(
+            "query.query",
+            "length",
+            "Discovery query must contain at most 100 UTF-16 code units",
+        )
+    if (input?.categoryId !== undefined && !integer(input.categoryId, 8))
+        return inputValidationFailure(
+            "query.categoryId",
+            "range",
+            "Discovery category ID must be an integer from 0 through 8",
+        )
+    if (
+        input?.primaryLanguage !== undefined &&
+        (!text(input.primaryLanguage, 2, 35) || !/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(input.primaryLanguage))
+    )
+        return inputValidationFailure(
+            "query.primaryLanguage",
+            "format",
+            "Discovery primary language must be a 2 through 35 UTF-16 code unit language tag",
+        )
+    if (input?.tag !== undefined && !text(input.tag, 0, 30))
+        return inputValidationFailure("query.tag", "length", "Discovery tag must contain at most 30 UTF-16 code units")
+    if (input?.sortBy !== undefined && !["memberCount", "onlineCount", "relevance"].includes(input.sortBy))
+        return inputValidationFailure(
+            "query.sortBy",
+            "allowedValue",
+            "Discovery sortBy must be memberCount, onlineCount, or relevance",
+        )
+    if (input?.limit !== undefined && (!integer(input.limit, 48) || input.limit === 0))
+        return inputValidationFailure("query.limit", "range", "Discovery limit must be an integer from 1 through 48")
+    if (input?.offset !== undefined && !integer(input.offset))
+        return inputValidationFailure("query.offset", "range", "Discovery offset must be a nonnegative safe integer")
+    const limit = input?.limit ?? 24
+    const offset = input?.offset ?? 0
+    const parameters = new URLSearchParams({ limit: String(limit), offset: String(offset) })
+    if (input?.query !== undefined) parameters.set("query", input.query)
+    if (input?.categoryId !== undefined) parameters.set("category", String(input.categoryId))
+    if (input?.primaryLanguage !== undefined) parameters.set("language", input.primaryLanguage)
+    if (input?.tag !== undefined) parameters.set("tag", input.tag)
+    if (input?.sortBy !== undefined)
+        parameters.set(
+            "sort_by",
+            { memberCount: "member_count", onlineCount: "online_count", relevance: "relevance" }[input.sortBy],
+        )
+    return {
+        guildId: "discovery",
+        bucket: "discovery:search",
+        path: `/discovery/guilds?${parameters}`,
+        method: "GET",
+        status: 200,
+        decode: (value) => {
+            if (
+                !record(value) ||
+                !Array.isArray(value.guilds) ||
+                !integer(value.total) ||
+                !Array.isArray(value.category_counts)
+            )
+                return undefined
+            const guilds = value.guilds.map(discoveryGuild)
+            if (guilds.length > limit || guilds.some((guild) => guild === undefined)) return undefined
+            const guildIds = new Set<string>()
+            if (guilds.some((guild) => !guild || guildIds.has(guild.id) || (guildIds.add(guild.id), false)))
+                return undefined
+            const categoryIds = new Set<number>()
+            const categoryCounts: DiscoveryCategoryCount[] = []
+            for (const item of value.category_counts) {
+                if (
+                    !record(item) ||
+                    !integer(item.category_type, 8) ||
+                    !integer(item.count) ||
+                    categoryIds.has(item.category_type)
+                )
+                    return undefined
+                categoryIds.add(item.category_type)
+                categoryCounts.push(Object.freeze({ categoryId: item.category_type, count: item.count }))
+            }
+            return Object.freeze({
+                guilds: Object.freeze(guilds as DiscoveryGuild[]),
+                total: value.total,
+                categoryCounts: Object.freeze(categoryCounts),
+                offset,
+                limit,
+            })
+        },
+    }
+}
+
+function body(input: DiscoveryApplicationInput | DiscoveryApplicationEdit, patch: boolean) {
+    if (!record(input)) return inputValidationFailure("input", "type", "Discovery application input must be an object")
+    const unsupported = unsupportedKeyFailure(
+        input,
+        ["description", "categoryId", "primaryLanguage", "tags"],
+        "input",
+        "the discovery application input",
+    )
+    if (unsupported) return unsupported
+    if ((!patch || input.description !== undefined) && !text(input.description, 10, 300))
+        return inputValidationFailure(
+            "description",
+            "length",
+            "Discovery description must contain 10 through 300 characters",
+        )
+    if ((!patch || input.categoryId !== undefined) && !integer(input.categoryId, 8))
+        return inputValidationFailure("categoryId", "range", "Discovery categoryId must be an integer from 0 through 8")
+    if (
+        input.primaryLanguage !== undefined &&
+        (!text(input.primaryLanguage, 2, 35) || !/^[A-Za-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/.test(input.primaryLanguage))
+    )
+        return inputValidationFailure(
+            "primaryLanguage",
+            "format",
+            "Discovery primary language must be a valid language tag",
+        )
+    const rawTags = input.tags
+    let tags: string[] | undefined
+    if (rawTags !== undefined) {
+        if (!Array.isArray(rawTags))
+            return inputValidationFailure("tags", "length", "Discovery tags must be an array with at most ten entries")
+        const count = rawTags.length
+        if (count > 10)
+            return inputValidationFailure("tags", "length", "Discovery tags must be an array with at most ten entries")
+        tags = []
+        for (let index = 0; index < count; index++) {
+            const tag = rawTags[index]
+            if (!text(tag, 2, 30))
+                return inputValidationFailure("tags[]", "length", "Discovery tags must contain 2 through 30 characters")
+            const normalized = tag.trim().toLowerCase().replace(/\s+/g, " ")
+            if (!text(normalized, 2, 30) || !/^[\p{L}\p{N}][\p{L}\p{N} \-_+&]*$/u.test(normalized))
+                return inputValidationFailure(
+                    "tags[]",
+                    "format",
+                    "Discovery tags must use supported letters, numbers, and separators",
+                )
+            if (!tags.includes(normalized)) tags.push(normalized)
+        }
+    }
+    const json = JSON.stringify({
+        description: input.description,
+        category_type: input.categoryId,
+        primary_language: input.primaryLanguage,
+        custom_tags: tags,
+    })
+    return json === "{}"
+        ? inputValidationFailure("input", "required", "Discovery application edit must contain a change")
+        : json
+}
+
+export function discoveryWrite(
+    guildId: string,
+    input: DiscoveryApplicationInput | DiscoveryApplicationEdit,
+    patch = false,
+): GuildRequest<DiscoveryApplication> | InputValidationFailure {
+    const base = discoveryStatus(guildId),
+        json = body(input, patch)
+    if (base instanceof InputValidationFailure) return base
+    if (json instanceof InputValidationFailure) return json
+    return {
+        ...base,
+        bucket: "guild:discovery:update",
+        method: patch ? "PATCH" : "POST",
+        json,
+        cache: { selection: { kind: "guilds", guildId }, mutation: true },
+        decode: (value) => application(value, guildId),
+    }
+}
+
+export function discoveryWithdraw(guildId: string): GuildRequest<void> | InputValidationFailure {
+    const base = discoveryStatus(guildId)
+    if (base instanceof InputValidationFailure) return base
+    return {
+        ...base,
+        bucket: "guild:discovery:update",
+        method: "DELETE",
+        status: 204,
+        cache: { selection: { kind: "guilds", guildId }, mutation: true },
+        decode: () => undefined,
+    }
+}

package/src/internal/guild-lifecycle.ts

@@ -0,0 +1,128 @@
+/**
+ * Guild list, leave and bulk own-message deletion requests, including the required deletion confirmation.
+ * Invariant: Requests are validated locally, and list summaries keep only decoded public fields.
+ * Implements [SDK contracts: Delivery, requests and caches](/docs/SDK-CONTRACTS.md#delivery-requests-and-caches)
+ */
+import type { GuildListQuery, GuildListSummary } from "#sdk/guilds"
+import { decodeGuild, type GuildRequest } from "./guilds.js"
+import { count, identifier, record } from "./decode/primitives.js"
+import { rejectCheck } from "./decode/trace.js"
+import { InputValidationFailure, inputValidationFailure, unsupportedKeyFailure } from "#sdk/input-validation"
+
+const unsigned64 = (value: unknown): value is string =>
+    typeof value === "string" &&
+    value.length <= 20 &&
+    /^(0|[1-9][0-9]*)$/.test(value) &&
+    BigInt(value) <= (1n << 64n) - 1n
+
+function decodeGuildListSummary(value: unknown): GuildListSummary | undefined {
+    const guild = decodeGuild(value)
+    if (!guild || !record(value)) return undefined
+    if (value.permissions !== undefined && !unsigned64(value.permissions)) return undefined
+    if (value.approximate_member_count !== undefined && !count(value.approximate_member_count)) return undefined
+    if (value.approximate_presence_count !== undefined && !count(value.approximate_presence_count)) return undefined
+    // Fluxer sends threads_active only as true, on communities where the caller can use threads
+    if (value.threads_active !== undefined && typeof value.threads_active !== "boolean") return undefined
+    return Object.freeze({
+        ...guild,
+        threadsActive: value.threads_active === true,
+        ...(value.permissions === undefined ? {} : { permissions: BigInt(value.permissions) }),
+        ...(value.approximate_member_count === undefined
+            ? {}
+            : { approximateMemberCount: value.approximate_member_count }),
+        ...(value.approximate_presence_count === undefined
+            ? {}
+            : { approximatePresenceCount: value.approximate_presence_count }),
+    })
+}
+
+export function guildList(
+    query: GuildListQuery = {},
+): GuildRequest<readonly GuildListSummary[]> | InputValidationFailure {
+    if (!record(query)) return inputValidationFailure("query", "type", "Guild list query must be an object")
+    const unsupported = unsupportedKeyFailure(
+        query,
+        ["limit", "before", "after", "withCounts"],
+        "query",
+        "the guild list query",
+    )
+    if (unsupported) return unsupported
+    if (query.before !== undefined && !identifier(query.before))
+        return inputValidationFailure("query", "format", "Guild list cursor IDs must be decimal strings")
+    if (query.after !== undefined && !identifier(query.after))
+        return inputValidationFailure("query", "format", "Guild list cursor IDs must be decimal strings")
+    if (query.before !== undefined && query.after !== undefined)
+        return inputValidationFailure("query", "format", "Guild list query cannot combine before and after")
+    if (query.withCounts !== undefined && typeof query.withCounts !== "boolean")
+        return inputValidationFailure("query", "format", "Guild list withCounts must be a boolean")
+    const limit = query.limit === undefined ? 200 : query.limit
+    if (typeof limit !== "number" || !Number.isInteger(limit) || limit < 1 || limit > 200)
+        return inputValidationFailure("query.limit", "range", "Guild list limit must be an integer from 1 through 200")
+    const params = new URLSearchParams({ limit: String(limit), with_counts: String(query.withCounts === true) })
+    if (query.before !== undefined) params.set("before", query.before)
+    if (query.after !== undefined) params.set("after", query.after)
+    return {
+        guildId: "@me",
+        bucket: "user:guilds:list",
+        path: `/users/@me/guilds?${params}`,
+        method: "GET",
+        status: 200,
+        decode: (value) => {
+            if (!Array.isArray(value) || value.length > limit) return undefined
+            const guilds: GuildListSummary[] = []
+            let previous: bigint | undefined
+            for (const item of value) {
+                const guild = decodeGuildListSummary(item)
+                if (!guild) return undefined
+                if (previous !== undefined && BigInt(guild.id) <= previous) return rejectCheck("order")
+                previous = BigInt(guild.id)
+                guilds.push(guild)
+            }
+            return Object.freeze(guilds)
+        },
+    }
+}
+
+export function guildLeave(guildId: string): GuildRequest<void> | InputValidationFailure {
+    if (!identifier(guildId)) return inputValidationFailure("guildId", "format", "Guild IDs must be decimal strings")
+    return {
+        guildId,
+        bucket: "user:guilds:leave",
+        path: `/users/@me/guilds/${guildId}?delete_messages=false`,
+        method: "DELETE",
+        status: 204,
+        cache: { selection: { kind: "guilds", guildId }, mutation: true, wholeGuild: true },
+        channelCache: { guildId, mutation: true },
+        invalidateMessages: true,
+        decode: () => undefined,
+    }
+}
+
+/**
+ * Check the required own-history deletion confirmation and return the remaining deadline and signal settings.
+ * The confirm field is removed so the shared option checks accept the rest unchanged
+ */
+export function ownDeletionOptions<O extends object>(options: unknown): O | InputValidationFailure {
+    if (!record(options) || options.confirm !== true)
+        return inputValidationFailure(
+            "options.confirm",
+            "required",
+            "Own-history deletion requires options with confirm: true",
+        )
+    const { confirm: _confirm, ...rest } = options
+    return rest as O
+}
+
+/** Builds the authenticated member's whole-guild message deletion request without changing membership or roles */
+export function guildDeleteOwnMessages(guildId: string): GuildRequest<void> | InputValidationFailure {
+    if (!identifier(guildId)) return inputValidationFailure("guildId", "format", "Guild IDs must be decimal strings")
+    return {
+        guildId,
+        bucket: "user:guilds:bulk-delete-mine",
+        path: `/users/@me/guilds/${guildId}/messages/bulk-delete-mine`,
+        method: "POST",
+        status: 202,
+        invalidateMessages: true,
+        decode: () => undefined,
+    }
+}

package/src/internal/guild-settings.ts

@@ -0,0 +1,209 @@
+/**
+ * Guild settings edits.
+ * Invariant: The edit is the bot-permitted settings patch, and REST owns dispatch, retry, audit headers and cache invalidation.
+ * Implements [SDK contracts: Delivery, requests and caches](/docs/SDK-CONTRACTS.md#delivery-requests-and-caches)
+ */
+import {
+    GuildFeatureToggles,
+    type Guild,
+    type GuildEdit,
+    type GuildFeatureToggle,
+    type ModerationOptions,
+} from "#sdk/guilds"
+import { decodeGuild, type GuildRequest } from "./guilds.js"
+import { identifier, record, snapshotArray } from "./decode/primitives.js"
+import { auditSettings } from "./moderation.js"
+import { InputValidationFailure, inputValidationFailure, unsupportedKeyFailure } from "#sdk/input-validation"
+import { timestamp } from "./decode/timestamp.js"
+import { normalizedText as text, rawText } from "./field-text.js"
+
+const imageDataUri = (value: unknown): value is string =>
+    typeof value === "string" &&
+    /^data:image\/[a-zA-Z0-9.+-]+(?:;[a-zA-Z0-9.+-]+(?:=[a-zA-Z0-9!#$&^_.+-]+)?)*;base64,(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=|[A-Za-z0-9+/]{4})$/.test(
+        value,
+    )
+const nullableIdentifier = (value: unknown): value is string | null => value === null || identifier(value)
+const guildFeatureToggles = new Set<GuildFeatureToggle>(Object.values(GuildFeatureToggles))
+
+/** Builds the bot-permitted guild settings patch. REST owns dispatch, retry, audit headers and cache invalidation */
+export function guildEdit(
+    guildId: string,
+    input: GuildEdit,
+    options?: ModerationOptions,
+): GuildRequest<Guild> | InputValidationFailure {
+    const audit = auditSettings(options)
+    if (!identifier(guildId)) return inputValidationFailure("guildId", "format", "Guild IDs must be decimal strings")
+    if (!record(input)) return inputValidationFailure("input", "type", "Guild settings input must be an object")
+    if (audit instanceof InputValidationFailure) return audit
+    const rawFeatureToggles = input.featureToggles
+    const messageHistoryCutoff = input.messageHistoryCutoff
+    const featureToggles =
+        rawFeatureToggles === undefined ? undefined : snapshotArray(rawFeatureToggles, guildFeatureToggles.size)
+    const unsupported = unsupportedKeyFailure(
+        input,
+        [
+            "name",
+            "icon",
+            "banner",
+            "splash",
+            "embedSplash",
+            "systemChannelId",
+            "systemChannelFlags",
+            "afkChannelId",
+            "afkTimeoutSeconds",
+            "defaultMessageNotifications",
+            "verificationLevel",
+            "nsfw",
+            "contentWarningLevel",
+            "contentWarningText",
+            "explicitContentFilter",
+            "splashCardAlignment",
+            "featureToggles",
+            "messageHistoryCutoff",
+        ],
+        "input",
+        "the guild settings input",
+    )
+    if (unsupported) return unsupported
+    if (input.name !== undefined && !text(input.name, 1, 100))
+        return inputValidationFailure(
+            "name",
+            "length",
+            "Community name must contain 1 through 100 UTF-16 code units after Fluxer's normalization",
+        )
+    for (const [path, label, value] of [
+        ["icon", "icon", input.icon],
+        ["banner", "banner", input.banner],
+        ["splash", "splash", input.splash],
+        ["embedSplash", "embed splash", input.embedSplash],
+    ] as const)
+        if (value !== undefined && value !== null && !imageDataUri(value))
+            return inputValidationFailure(path, "format", `Guild ${label} must be null or a base64 image data URI`)
+    if (input.systemChannelId !== undefined && !nullableIdentifier(input.systemChannelId))
+        return inputValidationFailure("systemChannelId", "format", "System channel ID must be null or a decimal string")
+    if (input.systemChannelFlags !== undefined && input.systemChannelFlags !== 0 && input.systemChannelFlags !== 1)
+        return inputValidationFailure("systemChannelFlags", "allowedValue", "System channel flags must be 0 or 1")
+    if (input.afkChannelId !== undefined && !nullableIdentifier(input.afkChannelId))
+        return inputValidationFailure("afkChannelId", "format", "AFK channel ID must be null or a decimal string")
+    if (
+        input.afkTimeoutSeconds !== undefined &&
+        !(
+            typeof input.afkTimeoutSeconds === "number" &&
+            Number.isInteger(input.afkTimeoutSeconds) &&
+            input.afkTimeoutSeconds >= 60 &&
+            input.afkTimeoutSeconds <= 3600
+        )
+    )
+        return inputValidationFailure(
+            "afkTimeoutSeconds",
+            "range",
+            "AFK timeout must be an integer from 60 through 3,600 seconds",
+        )
+    if (
+        input.defaultMessageNotifications !== undefined &&
+        input.defaultMessageNotifications !== 0 &&
+        input.defaultMessageNotifications !== 1
+    )
+        return inputValidationFailure(
+            "defaultMessageNotifications",
+            "allowedValue",
+            "Default message notifications must be 0 or 1",
+        )
+    if (
+        input.verificationLevel !== undefined &&
+        input.verificationLevel !== 0 &&
+        input.verificationLevel !== 1 &&
+        input.verificationLevel !== 2 &&
+        input.verificationLevel !== 3
+    )
+        return inputValidationFailure("verificationLevel", "allowedValue", "Verification level must be 0, 1, 2, or 3")
+    if (input.nsfw !== undefined && typeof input.nsfw !== "boolean")
+        return inputValidationFailure("nsfw", "type", "NSFW must be a boolean")
+    if (input.contentWarningLevel !== undefined && input.contentWarningLevel !== 0 && input.contentWarningLevel !== 1)
+        return inputValidationFailure("contentWarningLevel", "allowedValue", "Content warning level must be 0 or 1")
+    if (
+        input.contentWarningText !== undefined &&
+        input.contentWarningText !== null &&
+        !rawText(input.contentWarningText, 0, 200)
+    )
+        return inputValidationFailure(
+            "contentWarningText",
+            "length",
+            "Content warning text must be null or contain at most 200 raw UTF-16 code units",
+        )
+    if (
+        input.explicitContentFilter !== undefined &&
+        input.explicitContentFilter !== 0 &&
+        input.explicitContentFilter !== 1 &&
+        input.explicitContentFilter !== 2
+    )
+        return inputValidationFailure(
+            "explicitContentFilter",
+            "allowedValue",
+            "Explicit content filter must be 0, 1, or 2",
+        )
+    if (
+        input.splashCardAlignment !== undefined &&
+        input.splashCardAlignment !== 0 &&
+        input.splashCardAlignment !== 1 &&
+        input.splashCardAlignment !== 2
+    )
+        return inputValidationFailure("splashCardAlignment", "allowedValue", "Splash card alignment must be 0, 1, or 2")
+    if (
+        rawFeatureToggles !== undefined &&
+        (!featureToggles ||
+            !featureToggles.every((feature) => guildFeatureToggles.has(feature as GuildFeatureToggle)) ||
+            new Set(featureToggles).size !== featureToggles.length)
+    )
+        return inputValidationFailure(
+            "featureToggles[]",
+            "allowedValue",
+            "Feature toggles must be unique supported values",
+        )
+    if (messageHistoryCutoff !== undefined && messageHistoryCutoff !== null && !timestamp(messageHistoryCutoff))
+        return inputValidationFailure(
+            "messageHistoryCutoff",
+            "format",
+            "Message history cutoff must be null or an ISO 8601 timestamp with seconds and a Z or ±hh:mm offset",
+        )
+    const json = JSON.stringify({
+        name: input.name,
+        icon: input.icon,
+        banner: input.banner,
+        splash: input.splash,
+        embed_splash: input.embedSplash,
+        system_channel_id: input.systemChannelId,
+        system_channel_flags: input.systemChannelFlags,
+        afk_channel_id: input.afkChannelId,
+        afk_timeout: input.afkTimeoutSeconds,
+        default_message_notifications: input.defaultMessageNotifications,
+        verification_level: input.verificationLevel,
+        nsfw: input.nsfw,
+        content_warning_level: input.contentWarningLevel,
+        content_warning_text: input.contentWarningText,
+        explicit_content_filter: input.explicitContentFilter,
+        splash_card_alignment: input.splashCardAlignment,
+        features: featureToggles,
+        message_history_cutoff: messageHistoryCutoff,
+    })
+    if (json === "{}") return inputValidationFailure("input", "required", "Guild settings input must contain a change")
+    if (Buffer.byteLength(json) > 4_194_304)
+        return inputValidationFailure("input", "size", "Guild settings input must not exceed 4,194,304 encoded bytes")
+    return {
+        guildId,
+        bucket: "guild:settings:update",
+        path: `/guilds/${guildId}`,
+        method: "PATCH",
+        status: 200,
+        json,
+        ...audit,
+        cache: { selection: { kind: "guilds", guildId }, mutation: true },
+        ...(featureToggles !== undefined && !featureToggles.includes("TEXT_CHANNEL_FLEXIBLE_NAMES")
+            ? { channelCache: { guildId, mutation: true } }
+            : {}),
+        decode: (value) => {
+            const guild = decodeGuild(value)
+            return guild?.id === guildId ? guild : undefined
+        },
+    }
+}