disgroove 2.2.2 → 2.2.3-dev.4f98e3d

package/dist/lib/transformers/ApplicationCommands.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationCommands = void 0;
+class ApplicationCommands {
+    static applicationCommandFromRaw(command) {
+        return {
+            id: command.id,
+            type: command.type,
+            applicationID: command.application_id,
+            guildID: command.guild_id,
+            name: command.name,
+            nameLocalizations: command.name_localizations,
+            description: command.description,
+            descriptionLocalizations: command.description_localizations,
+            options: command.options?.map((option) => this.optionFromRaw(option)),
+            defaultMemberPermissions: command.default_member_permissions,
+            dmPermission: command.dm_permission,
+            defaultPermission: command.default_permission,
+            integrationTypes: command.integration_types,
+            contexts: command.contexts,
+            nsfw: command.nsfw,
+            version: command.version,
+        };
+    }
+    static applicationCommandToRaw(command) {
+        return {
+            id: command.id,
+            type: command.type,
+            application_id: command.applicationID,
+            guild_id: command.guildID,
+            name: command.name,
+            name_localizations: command.nameLocalizations,
+            description: command.description,
+            description_localizations: command.descriptionLocalizations,
+            options: command.options?.map((option) => this.optionToRaw(option)),
+            default_member_permissions: command.defaultMemberPermissions,
+            dm_permission: command.dmPermission,
+            default_permission: command.defaultPermission,
+            integration_types: command.integrationTypes,
+            contexts: command.contexts,
+            nsfw: command.nsfw,
+            version: command.version,
+        };
+    }
+    static optionToRaw(option) {
+        return {
+            type: option.type,
+            name: option.name,
+            name_localizations: option.nameLocalizations,
+            description: option.description,
+            description_localizations: option.descriptionLocalizations,
+            required: option.required,
+            choices: option.choices?.map((choice) => ({
+                name: choice.name,
+                name_localizations: choice.nameLocalizations,
+                value: choice.value,
+            })),
+            options: option.options?.map((o) => this.optionFromRaw(o)),
+            channel_types: option.channelTypes,
+            min_value: option.minValue,
+            max_value: option.maxValue,
+            min_length: option.minLength,
+            max_length: option.maxLength,
+            autocomplete: option.autocomplete,
+        };
+    }
+    static optionFromRaw(option) {
+        return {
+            type: option.type,
+            name: option.name,
+            nameLocalizations: option.name_localizations,
+            description: option.description,
+            descriptionLocalizations: option.description_localizations,
+            required: option.required,
+            choices: option.choices?.map((choice) => ({
+                name: choice.name,
+                nameLocalizations: choice.name_localizations,
+                value: choice.value,
+            })),
+            options: option.options?.map((o) => this.optionFromRaw(o)),
+            channelTypes: option.channel_types,
+            minValue: option.min_value,
+            maxValue: option.max_value,
+            minLength: option.min_length,
+            maxLength: option.max_length,
+            autocomplete: option.autocomplete,
+        };
+    }
+}
+exports.ApplicationCommands = ApplicationCommands;

package/dist/lib/transformers/ApplicationRoleConnectionMetadatas.d.ts

@@ -0,0 +1,5 @@
+import type { ApplicationRoleConnectionMetadata, RawApplicationRoleConnectionMetadata } from "../types/application-role-connection-metadata";
+export declare class ApplicationRoleConnectionMetadatas {
+    static applicationRoleConnectionMetadataFromRaw(connectionMetadata: RawApplicationRoleConnectionMetadata): ApplicationRoleConnectionMetadata;
+    static applicationRoleConnectionMetadataToRaw(connectionMetadata: ApplicationRoleConnectionMetadata): RawApplicationRoleConnectionMetadata;
+}

package/dist/lib/transformers/ApplicationRoleConnectionMetadatas.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApplicationRoleConnectionMetadatas = void 0;
+class ApplicationRoleConnectionMetadatas {
+    static applicationRoleConnectionMetadataFromRaw(connectionMetadata) {
+        return {
+            type: connectionMetadata.type,
+            key: connectionMetadata.key,
+            name: connectionMetadata.name,
+            nameLocalizations: connectionMetadata.name_localizations,
+            description: connectionMetadata.description,
+            descriptionLocalizations: connectionMetadata.description_localizations,
+        };
+    }
+    static applicationRoleConnectionMetadataToRaw(connectionMetadata) {
+        return {
+            type: connectionMetadata.type,
+            key: connectionMetadata.key,
+            name: connectionMetadata.name,
+            name_localizations: connectionMetadata.nameLocalizations,
+            description: connectionMetadata.description,
+            description_localizations: connectionMetadata.descriptionLocalizations,
+        };
+    }
+}
+exports.ApplicationRoleConnectionMetadatas = ApplicationRoleConnectionMetadatas;

package/dist/lib/transformers/Applications.d.ts

@@ -1,8 +1,5 @@
 import type { RawApplication, Application } from "../types/application";
-import type { RawApplicationCommand, ApplicationCommand } from "../types/application-command";
 export declare class Applications {
-    static applicationCommandFromRaw(applicationCommand: RawApplicationCommand): ApplicationCommand;
-    static applicationCommandToRaw(applicationCommand: ApplicationCommand): RawApplicationCommand;
     static applicationFromRaw(application: RawApplication): Application;
     static applicationToRaw(application: Application): RawApplication;
 }

package/dist/lib/transformers/Applications.js

@@ -5,120 +5,6 @@ const Guilds_1 = require("./Guilds");
 const Teams_1 = require("./Teams");
 const Users_1 = require("./Users");
 class Applications {
-    static applicationCommandFromRaw(applicationCommand) {
-        return {
-            id: applicationCommand.id,
-            type: applicationCommand.type,
-            applicationID: applicationCommand.application_id,
-            guildID: applicationCommand.guild_id,
-            name: applicationCommand.name,
-            nameLocalizations: applicationCommand.name_localizations,
-            description: applicationCommand.description,
-            descriptionLocalizations: applicationCommand.description_localizations,
-            options: applicationCommand.options?.map((option) => ({
-                type: option.type,
-                name: option.name,
-                name_localizations: option.name_localizations,
-                description: option.description,
-                description_localizations: option.description_localizations,
-                required: option.required,
-                choices: option.choices?.map((choice) => ({
-                    name: choice.name,
-                    name_localizations: choice.name_localizations,
-                    value: choice.value,
-                })),
-                options: option.options?.map((o) => ({
-                    type: o.type,
-                    name: o.name,
-                    name_localizations: o.name_localizations,
-                    description: o.description,
-                    description_localizations: o.description_localizations,
-                    required: o.required,
-                    choices: o.choices?.map((choice) => ({
-                        name: choice.name,
-                        name_localizations: choice.name_localizations,
-                        value: choice.value,
-                    })),
-                    channel_types: o.channel_types,
-                    min_value: o.min_value,
-                    max_value: o.max_value,
-                    min_length: o.min_length,
-                    max_length: o.max_length,
-                    autocomplete: o.autocomplete,
-                })),
-                channel_types: option.channel_types,
-                min_value: option.min_value,
-                max_value: option.max_value,
-                min_length: option.min_length,
-                max_length: option.max_length,
-                autocomplete: option.autocomplete,
-            })),
-            defaultMemberPermissions: applicationCommand.default_member_permissions,
-            dmPermission: applicationCommand.dm_permission,
-            defaultPermission: applicationCommand.default_permission,
-            integrationTypes: applicationCommand.integration_types,
-            contexts: applicationCommand.contexts,
-            nsfw: applicationCommand.nsfw,
-            version: applicationCommand.version,
-        };
-    }
-    static applicationCommandToRaw(applicationCommand) {
-        return {
-            id: applicationCommand.id,
-            type: applicationCommand.type,
-            application_id: applicationCommand.applicationID,
-            guild_id: applicationCommand.guildID,
-            name: applicationCommand.name,
-            name_localizations: applicationCommand.nameLocalizations,
-            description: applicationCommand.description,
-            description_localizations: applicationCommand.descriptionLocalizations,
-            options: applicationCommand.options?.map((option) => ({
-                type: option.type,
-                name: option.name,
-                name_localizations: option.nameLocalizations,
-                description: option.description,
-                description_localizations: option.descriptionLocalizations,
-                required: option.required,
-                choices: option.choices?.map((choice) => ({
-                    name: choice.name,
-                    name_localizations: choice.nameLocalizations,
-                    value: choice.value,
-                })),
-                options: option.options?.map((o) => ({
-                    type: o.type,
-                    name: o.name,
-                    name_localizations: o.nameLocalizations,
-                    description: o.description,
-                    description_localizations: o.descriptionLocalizations,
-                    required: o.required,
-                    choices: o.choices?.map((choice) => ({
-                        name: choice.name,
-                        name_localizations: choice.nameLocalizations,
-                        value: choice.value,
-                    })),
-                    channel_types: o.channelTypes,
-                    min_value: o.minValue,
-                    max_value: o.maxValue,
-                    min_length: o.minLength,
-                    max_length: o.maxLength,
-                    autocomplete: o.autocomplete,
-                })),
-                channel_types: option.channelTypes,
-                min_value: option.minValue,
-                max_value: option.maxValue,
-                min_length: option.minLength,
-                max_length: option.maxLength,
-                autocomplete: option.autocomplete,
-            })),
-            default_member_permissions: applicationCommand.defaultMemberPermissions,
-            dm_permission: applicationCommand.dmPermission,
-            default_permission: applicationCommand.defaultPermission,
-            integration_types: applicationCommand.integrationTypes,
-            contexts: applicationCommand.contexts,
-            nsfw: applicationCommand.nsfw,
-            version: applicationCommand.version,
-        };
-    }
     static applicationFromRaw(application) {
         return {
             id: application.id,

package/dist/lib/transformers/AuditLogs.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AuditLogs = void 0;
-const Applications_1 = require("./Applications");
+const ApplicationCommands_1 = require("./ApplicationCommands");
 const AutoModeration_1 = require("./AutoModeration");
 const Channels_1 = require("./Channels");
 const Guilds_1 = require("./Guilds");
@@ -71,7 +71,7 @@ class AuditLogs {
     }
     static auditLogFromRaw(auditLog) {
         return {
-            applicationCommands: auditLog.application_commands.map((applicationCommand) => Applications_1.Applications.applicationCommandFromRaw(applicationCommand)),
+            applicationCommands: auditLog.application_commands.map((applicationCommand) => ApplicationCommands_1.ApplicationCommands.applicationCommandFromRaw(applicationCommand)),
             auditLogEntries: auditLog.audit_log_entries.map((auditLogEntry) => AuditLogs.auditLogEntryFromRaw(auditLogEntry)),
             autoModerationRules: auditLog.auto_moderation_rules.map((autoModerationRule) => AutoModeration_1.AutoModeration.autoModerationRuleFromRaw(autoModerationRule)),
             guildScheduledEvents: auditLog.guild_scheduled_events.map((guildScheduledEvent) => GuildScheduledEvents_1.GuildScheduledEvents.guildScheduledEventFromRaw(guildScheduledEvent)),
@@ -83,7 +83,7 @@ class AuditLogs {
     }
     static auditLogToRaw(auditLog) {
         return {
-            application_commands: auditLog.applicationCommands.map((applicationCommand) => Applications_1.Applications.applicationCommandToRaw(applicationCommand)),
+            application_commands: auditLog.applicationCommands.map((applicationCommand) => ApplicationCommands_1.ApplicationCommands.applicationCommandToRaw(applicationCommand)),
             audit_log_entries: auditLog.auditLogEntries.map((auditLogEntry) => AuditLogs.auditLogEntryToRaw(auditLogEntry)),
             auto_moderation_rules: auditLog.autoModerationRules.map((autoModerationRule) => AutoModeration_1.AutoModeration.autoModerationRuleToRaw(autoModerationRule)),
             guild_scheduled_events: auditLog.guildScheduledEvents.map((guildScheduledEvent) => GuildScheduledEvents_1.GuildScheduledEvents.guildScheduledEventToRaw(guildScheduledEvent)),

package/dist/lib/transformers/AutoModeration.d.ts

@@ -1,5 +1,9 @@
-import type { AutoModerationRule, RawAutoModerationRule } from "../types/auto-moderation";
+import type { AutoModerationAction, AutoModerationRule, RawAutoModerationAction, RawAutoModerationRule, RawTriggerMetadata, TriggerMetadata } from "../types/auto-moderation";
 export declare class AutoModeration {
+    static actionFromRaw(action: RawAutoModerationAction): AutoModerationAction;
+    static actionToRaw(action: AutoModerationAction): RawAutoModerationAction;
     static autoModerationRuleFromRaw(autoModerationRule: RawAutoModerationRule): AutoModerationRule;
     static autoModerationRuleToRaw(autoModerationRule: AutoModerationRule): RawAutoModerationRule;
+    static triggerMetadataFromRaw(triggerMetadata: RawTriggerMetadata): TriggerMetadata;
+    static triggerMetadataToRaw(triggerMetadata: TriggerMetadata): RawTriggerMetadata;
 }

package/dist/lib/transformers/AutoModeration.js

@@ -2,6 +2,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AutoModeration = void 0;
 class AutoModeration {
+    static actionFromRaw(action) {
+        return {
+            type: action.type,
+            metadata: {
+                channelID: action.metadata.channel_id,
+                durationSeconds: action.metadata.duration_seconds,
+                customMessage: action.metadata.custom_message,
+            },
+        };
+    }
+    static actionToRaw(action) {
+        return {
+            type: action.type,
+            metadata: {
+                channel_id: action.metadata.channelID,
+                duration_seconds: action.metadata.durationSeconds,
+                custom_message: action.metadata.customMessage,
+            },
+        };
+    }
     static autoModerationRuleFromRaw(autoModerationRule) {
         return {
             id: autoModerationRule.id,
@@ -10,22 +30,8 @@ class AutoModeration {
             creatorID: autoModerationRule.creator_id,
             eventType: autoModerationRule.event_type,
             triggerType: autoModerationRule.trigger_type,
-            triggerMetadata: {
-                keywordFilter: autoModerationRule.trigger_metadata.keyword_filter,
-                regexPatterns: autoModerationRule.trigger_metadata.regex_patterns,
-                presets: autoModerationRule.trigger_metadata.presets,
-                allowList: autoModerationRule.trigger_metadata.allow_list,
-                mentionTotalLimit: autoModerationRule.trigger_metadata.mention_total_limit,
-                mentionRaidProtection: autoModerationRule.trigger_metadata.mention_raid_protection,
-            },
-            actions: autoModerationRule.actions.map((action) => ({
-                type: action.type,
-                metadata: {
-                    channelID: action.metadata.channel_id,
-                    durationSeconds: action.metadata.duration_seconds,
-                    customMessage: action.metadata.custom_message,
-                },
-            })),
+            triggerMetadata: this.triggerMetadataFromRaw(autoModerationRule.trigger_metadata),
+            actions: autoModerationRule.actions.map((action) => this.actionFromRaw(action)),
             enabled: autoModerationRule.enabled,
             exemptRoles: autoModerationRule.exempt_roles,
             exemptChannels: autoModerationRule.exempt_channels,
@@ -39,26 +45,32 @@ class AutoModeration {
             creator_id: autoModerationRule.creatorID,
             event_type: autoModerationRule.eventType,
             trigger_type: autoModerationRule.triggerType,
-            trigger_metadata: {
-                keyword_filter: autoModerationRule.triggerMetadata.keywordFilter,
-                regex_patterns: autoModerationRule.triggerMetadata.regexPatterns,
-                presets: autoModerationRule.triggerMetadata.presets,
-                allow_list: autoModerationRule.triggerMetadata.allowList,
-                mention_total_limit: autoModerationRule.triggerMetadata.mentionTotalLimit,
-                mention_raid_protection: autoModerationRule.triggerMetadata.mentionRaidProtection,
-            },
-            actions: autoModerationRule.actions.map((action) => ({
-                type: action.type,
-                metadata: {
-                    channel_id: action.metadata.channelID,
-                    duration_seconds: action.metadata.durationSeconds,
-                    custom_message: action.metadata.customMessage,
-                },
-            })),
+            trigger_metadata: this.triggerMetadataToRaw(autoModerationRule.triggerMetadata),
+            actions: autoModerationRule.actions.map((action) => this.actionToRaw(action)),
             enabled: autoModerationRule.enabled,
             exempt_roles: autoModerationRule.exemptRoles,
             exempt_channels: autoModerationRule.exemptChannels,
         };
     }
+    static triggerMetadataFromRaw(triggerMetadata) {
+        return {
+            keywordFilter: triggerMetadata.keyword_filter,
+            regexPatterns: triggerMetadata.regex_patterns,
+            presets: triggerMetadata.presets,
+            allowList: triggerMetadata.allow_list,
+            mentionTotalLimit: triggerMetadata.mention_total_limit,
+            mentionRaidProtection: triggerMetadata.mention_raid_protection,
+        };
+    }
+    static triggerMetadataToRaw(triggerMetadata) {
+        return {
+            keyword_filter: triggerMetadata.keywordFilter,
+            regex_patterns: triggerMetadata.regexPatterns,
+            presets: triggerMetadata.presets,
+            allow_list: triggerMetadata.allowList,
+            mention_total_limit: triggerMetadata.mentionTotalLimit,
+            mention_raid_protection: triggerMetadata.mentionRaidProtection,
+        };
+    }
 }
 exports.AutoModeration = AutoModeration;

package/dist/lib/transformers/Guilds.js

@@ -103,6 +103,14 @@ class Guilds {
             pending: guildMember.pending,
             permissions: guildMember.permissions,
             communicationDisabledUntil: guildMember.communication_disabled_until,
+            avatarDecorationData: guildMember.avatar_decoration_data !== undefined
+                ? guildMember.avatar_decoration_data !== null
+                    ? {
+                        asset: guildMember.avatar_decoration_data.asset,
+                        skuID: guildMember.avatar_decoration_data.sku_id,
+                    }
+                    : null
+                : undefined,
         };
     }
     static guildMemberToRaw(guildMember) {
@@ -121,6 +129,14 @@ class Guilds {
             pending: guildMember.pending,
             permissions: guildMember.permissions,
             communication_disabled_until: guildMember.communicationDisabledUntil,
+            avatar_decoration_data: guildMember.avatarDecorationData !== undefined
+                ? guildMember.avatarDecorationData !== null
+                    ? {
+                        asset: guildMember.avatarDecorationData.asset,
+                        sku_id: guildMember.avatarDecorationData.skuID,
+                    }
+                    : null
+                : undefined,
         };
     }
     static guildToRaw(guild) {

package/dist/lib/transformers/Presences.d.ts

@@ -1,8 +1,5 @@
 import type { RawPresenceUpdateEventFields, PresenceUpdateEventFields } from "../types/gateway-events";
-import type { RawUser, User } from "../types/user";
 export declare class Presences {
     static presenceFromRaw(presence: RawPresenceUpdateEventFields): PresenceUpdateEventFields;
     static presenceToRaw(presence: PresenceUpdateEventFields): RawPresenceUpdateEventFields;
-    static presenceUserFromRaw(user: Pick<RawUser, "id"> & Partial<RawUser>): Pick<User, "id"> & Partial<User>;
-    static presenceUserToRaw(user: Pick<User, "id"> & Partial<User>): Pick<RawUser, "id"> & Partial<RawUser>;
 }

package/dist/lib/transformers/Presences.js

@@ -4,7 +4,32 @@ exports.Presences = void 0;
 class Presences {
     static presenceFromRaw(presence) {
         return {
-            user: Presences.presenceUserFromRaw(presence.user),
+            user: {
+                id: presence.user.id,
+                username: presence.user.username,
+                discriminator: presence.user.discriminator,
+                globalName: presence.user.global_name,
+                avatar: presence.user.avatar,
+                bot: presence.user.bot,
+                system: presence.user.system,
+                mfaEnabled: presence.user.mfa_enabled,
+                banner: presence.user.banner,
+                accentColor: presence.user.accent_color,
+                locale: presence.user.locale,
+                verified: presence.user.verified,
+                email: presence.user.email,
+                flags: presence.user.flags,
+                premiumType: presence.user.premium_type,
+                publicFlags: presence.user.public_flags,
+                avatarDecorationData: presence.user.avatar_decoration_data !== undefined
+                    ? presence.user.avatar_decoration_data !== null
+                        ? {
+                            asset: presence.user.avatar_decoration_data.asset,
+                            skuID: presence.user.avatar_decoration_data.sku_id,
+                        }
+                        : null
+                    : undefined,
+            },
             guildID: presence.guild_id,
             status: presence.status,
             activities: presence.activities.map((activity) => ({
@@ -34,7 +59,32 @@ class Presences {
     }
     static presenceToRaw(presence) {
         return {
-            user: Presences.presenceUserToRaw(presence.user),
+            user: {
+                id: presence.user.id,
+                username: presence.user.username,
+                discriminator: presence.user.discriminator,
+                global_name: presence.user.globalName,
+                avatar: presence.user.avatar,
+                bot: presence.user.bot,
+                system: presence.user.system,
+                mfa_enabled: presence.user.mfaEnabled,
+                banner: presence.user.banner,
+                accent_color: presence.user.accentColor,
+                locale: presence.user.locale,
+                verified: presence.user.verified,
+                email: presence.user.email,
+                flags: presence.user.flags,
+                premium_type: presence.user.premiumType,
+                public_flags: presence.user.publicFlags,
+                avatar_decoration_data: presence.user.avatarDecorationData !== undefined
+                    ? presence.user.avatarDecorationData !== null
+                        ? {
+                            asset: presence.user.avatarDecorationData.asset,
+                            sku_id: presence.user.avatarDecorationData.skuID,
+                        }
+                        : null
+                    : undefined,
+            },
             guild_id: presence.guildID,
             status: presence.status,
             activities: presence.activities.map((activity) => ({
@@ -62,47 +112,5 @@ class Presences {
             client_status: presence.clientStatus,
         };
     }
-    static presenceUserFromRaw(user) {
-        return {
-            id: user.id,
-            username: user.username,
-            discriminator: user.discriminator,
-            globalName: user.global_name,
-            avatar: user.avatar,
-            bot: user.bot,
-            system: user.system,
-            mfaEnabled: user.mfa_enabled,
-            banner: user.banner,
-            accentColor: user.accent_color,
-            locale: user.locale,
-            verified: user.verified,
-            email: user.email,
-            flags: user.flags,
-            premiumType: user.premium_type,
-            publicFlags: user.public_flags,
-            avatarDecoration: user.avatar_decoration,
-        };
-    }
-    static presenceUserToRaw(user) {
-        return {
-            id: user.id,
-            username: user.username,
-            discriminator: user.discriminator,
-            global_name: user.globalName,
-            avatar: user.avatar,
-            bot: user.bot,
-            system: user.system,
-            mfa_enabled: user.mfaEnabled,
-            banner: user.banner,
-            accent_color: user.accentColor,
-            locale: user.locale,
-            verified: user.verified,
-            email: user.email,
-            flags: user.flags,
-            premium_type: user.premiumType,
-            public_flags: user.publicFlags,
-            avatar_decoration: user.avatarDecoration,
-        };
-    }
 }
 exports.Presences = Presences;

package/dist/lib/transformers/Users.js

@@ -20,7 +20,14 @@ class Users {
             flags: user.flags,
             premiumType: user.premium_type,
             publicFlags: user.public_flags,
-            avatarDecoration: user.avatar_decoration,
+            avatarDecorationData: user.avatar_decoration_data !== undefined
+                ? user.avatar_decoration_data !== null
+                    ? {
+                        asset: user.avatar_decoration_data.asset,
+                        skuID: user.avatar_decoration_data.sku_id,
+                    }
+                    : null
+                : undefined,
         };
     }
     static userToRaw(user) {
@@ -41,7 +48,14 @@ class Users {
             flags: user.flags,
             premium_type: user.premiumType,
             public_flags: user.publicFlags,
-            avatar_decoration: user.avatarDecoration,
+            avatar_decoration_data: user.avatarDecorationData !== undefined
+                ? user.avatarDecorationData !== null
+                    ? {
+                        asset: user.avatarDecorationData.asset,
+                        sku_id: user.avatarDecorationData.skuID,
+                    }
+                    : null
+                : undefined,
         };
     }
 }

package/dist/lib/transformers/index.d.ts

@@ -1,3 +1,5 @@
+export * from "./ApplicationCommands";
+export * from "./ApplicationRoleConnectionMetadatas";
 export * from "./Applications";
 export * from "./AuditLogs";
 export * from "./AutoModeration";

package/dist/lib/transformers/index.js

@@ -14,6 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ApplicationCommands"), exports);
+__exportStar(require("./ApplicationRoleConnectionMetadatas"), exports);
 __exportStar(require("./Applications"), exports);
 __exportStar(require("./AuditLogs"), exports);
 __exportStar(require("./AutoModeration"), exports);

package/dist/lib/types/guild.d.ts

@@ -4,7 +4,7 @@ import type { snowflake, timestamp } from "./common";
 import type { RawEmoji, Emoji } from "./emoji";
 import type { RawRole, Role } from "./role";
 import type { RawSticker, Sticker } from "./sticker";
-import type { RawUser, User } from "./user";
+import type { AvatarDecorationData, RawAvatarDecorationData, RawUser, User } from "./user";
 /** https://discord.com/developers/docs/resources/guild#guild-object-guild-structure */
 export interface RawGuild {
     id: snowflake;
@@ -98,6 +98,7 @@ export interface RawGuildMember {
     pending?: boolean;
     permissions?: string;
     communication_disabled_until?: number | null;
+    avatar_decoration_data?: RawAvatarDecorationData | null;
 }
 /** https://discord.com/developers/docs/resources/guild#integration-object-integration-structure */
 export interface RawIntegration {
@@ -265,6 +266,7 @@ export interface GuildMember {
     pending?: boolean;
     permissions?: string;
     communicationDisabledUntil?: number | null;
+    avatarDecorationData?: AvatarDecorationData | null;
 }
 export interface Integration {
     id: snowflake;

package/dist/lib/types/user.d.ts

@@ -20,7 +20,7 @@ export interface RawUser {
     flags?: UserFlags;
     premium_type?: PremiumTypes;
     public_flags?: UserFlags;
-    avatar_decoration?: string | null;
+    avatar_decoration_data?: RawAvatarDecorationData | null;
 }
 /** https://discord.com/developers/docs/resources/user#avatar-decoration-data-object-avatar-decoration-data-structure */
 export interface RawAvatarDecorationData {
@@ -63,7 +63,7 @@ export interface User {
     flags?: UserFlags;
     premiumType?: PremiumTypes;
     publicFlags?: UserFlags;
-    avatarDecoration?: string | null;
+    avatarDecorationData?: AvatarDecorationData | null;
 }
 export interface AvatarDecorationData {
     asset: string;