disgroove 2.2.2-dev.bd3875c → 2.2.2

package/dist/lib/transformers/Emojis.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emojis = void 0;
+const Users_1 = require("./Users");
+class Emojis {
+    static emojiFromRaw(emoji) {
+        return {
+            id: emoji.id,
+            name: emoji.name,
+            roles: emoji.roles,
+            user: emoji.user !== undefined ? Users_1.Users.userFromRaw(emoji.user) : undefined,
+            requireColons: emoji.require_colons,
+            managed: emoji.managed,
+            animated: emoji.animated,
+            available: emoji.available,
+        };
+    }
+    static emojiToRaw(emoji) {
+        return {
+            id: emoji.id,
+            name: emoji.name,
+            roles: emoji.roles,
+            user: emoji.user !== undefined ? Users_1.Users.userToRaw(emoji.user) : undefined,
+            require_colons: emoji.requireColons,
+            managed: emoji.managed,
+            animated: emoji.animated,
+            available: emoji.available,
+        };
+    }
+}
+exports.Emojis = Emojis;

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

@@ -0,0 +1,7 @@
+import type { RawEntitlement, Entitlement } from "../types/entitlements";
+export declare class Entitlements {
+    static entitlementFromRaw(entitlement: RawEntitlement): Entitlement;
+    static entitlementToRaw(entitlement: Entitlement): RawEntitlement;
+    static testEntitlementFromRaw(entitlement: Omit<RawEntitlement, "starts_at" | "ends_at" | "subscription_id">): Omit<Entitlement, "startsAt" | "endsAt" | "subscriptionID">;
+    static testEntitlementToRaw(entitlement: Omit<Entitlement, "startsAt" | "endsAt" | "subscriptionID">): Omit<RawEntitlement, "starts_at" | "ends_at" | "subscription_id">;
+}

package/dist/lib/transformers/Entitlements.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Entitlements = void 0;
+class Entitlements {
+    static entitlementFromRaw(entitlement) {
+        return {
+            id: entitlement.id,
+            skuID: entitlement.sku_id,
+            applicationID: entitlement.application_id,
+            userID: entitlement.user_id,
+            type: entitlement.type,
+            deleted: entitlement.deleted,
+            consumed: entitlement.consumed,
+            startsAt: entitlement.starts_at,
+            endsAt: entitlement.ends_at,
+            guildID: entitlement.guild_id,
+        };
+    }
+    static entitlementToRaw(entitlement) {
+        return {
+            id: entitlement.id,
+            sku_id: entitlement.skuID,
+            application_id: entitlement.applicationID,
+            user_id: entitlement.userID,
+            type: entitlement.type,
+            deleted: entitlement.deleted,
+            consumed: entitlement.consumed,
+            starts_at: entitlement.startsAt,
+            ends_at: entitlement.endsAt,
+            guild_id: entitlement.guildID,
+        };
+    }
+    static testEntitlementFromRaw(entitlement) {
+        return {
+            id: entitlement.id,
+            skuID: entitlement.sku_id,
+            applicationID: entitlement.application_id,
+            userID: entitlement.user_id,
+            type: entitlement.type,
+            deleted: entitlement.deleted,
+            consumed: entitlement.consumed,
+            guildID: entitlement.guild_id,
+        };
+    }
+    static testEntitlementToRaw(entitlement) {
+        return {
+            id: entitlement.id,
+            sku_id: entitlement.skuID,
+            application_id: entitlement.applicationID,
+            user_id: entitlement.userID,
+            type: entitlement.type,
+            deleted: entitlement.deleted,
+            consumed: entitlement.consumed,
+            guild_id: entitlement.guildID,
+        };
+    }
+}
+exports.Entitlements = Entitlements;

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

@@ -0,0 +1,5 @@
+import type { RawGuildScheduledEvent, GuildScheduledEvent } from "../types/guild-scheduled-event";
+export declare class GuildScheduledEvents {
+    static guildScheduledEventFromRaw(guildScheduledEvent: RawGuildScheduledEvent): GuildScheduledEvent;
+    static guildScheduledEventToRaw(guildScheduledEvent: GuildScheduledEvent): RawGuildScheduledEvent;
+}

package/dist/lib/transformers/GuildScheduledEvents.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildScheduledEvents = void 0;
+const Users_1 = require("./Users");
+class GuildScheduledEvents {
+    static guildScheduledEventFromRaw(guildScheduledEvent) {
+        return {
+            id: guildScheduledEvent.id,
+            guildID: guildScheduledEvent.guild_id,
+            channelID: guildScheduledEvent.channel_id,
+            creatorID: guildScheduledEvent.creator_id,
+            name: guildScheduledEvent.name,
+            description: guildScheduledEvent.description,
+            scheduledStartTime: guildScheduledEvent.scheduled_start_time,
+            scheduledEndTime: guildScheduledEvent.scheduled_end_time,
+            privacyLevel: guildScheduledEvent.privacy_level,
+            status: guildScheduledEvent.status,
+            entityType: guildScheduledEvent.entity_type,
+            entityID: guildScheduledEvent.entity_id,
+            entityMetadata: guildScheduledEvent.entity_metadata,
+            creator: guildScheduledEvent.creator !== undefined
+                ? Users_1.Users.userFromRaw(guildScheduledEvent.creator)
+                : undefined,
+            userCount: guildScheduledEvent.user_count,
+            image: guildScheduledEvent.image,
+        };
+    }
+    static guildScheduledEventToRaw(guildScheduledEvent) {
+        return {
+            id: guildScheduledEvent.id,
+            guild_id: guildScheduledEvent.guildID,
+            channel_id: guildScheduledEvent.channelID,
+            creator_id: guildScheduledEvent.creatorID,
+            name: guildScheduledEvent.name,
+            description: guildScheduledEvent.description,
+            scheduled_start_time: guildScheduledEvent.scheduledStartTime,
+            scheduled_end_time: guildScheduledEvent.scheduledEndTime,
+            privacy_level: guildScheduledEvent.privacyLevel,
+            status: guildScheduledEvent.status,
+            entity_type: guildScheduledEvent.entityType,
+            entity_id: guildScheduledEvent.entityID,
+            entity_metadata: guildScheduledEvent.entityMetadata,
+            creator: guildScheduledEvent.creator !== undefined
+                ? Users_1.Users.userToRaw(guildScheduledEvent.creator)
+                : undefined,
+            user_count: guildScheduledEvent.userCount,
+            image: guildScheduledEvent.image,
+        };
+    }
+}
+exports.GuildScheduledEvents = GuildScheduledEvents;

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

@@ -0,0 +1,5 @@
+import type { RawGuildTemplate, GuildTemplate } from "../types/guild-template";
+export declare class GuildTemplates {
+    static guildTemplateFromRaw(guildTemplate: RawGuildTemplate): GuildTemplate;
+    static guildTemplateToRaw(guildTemplate: GuildTemplate): RawGuildTemplate;
+}

package/dist/lib/transformers/GuildTemplates.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuildTemplates = void 0;
+const Guilds_1 = require("./Guilds");
+const Users_1 = require("./Users");
+class GuildTemplates {
+    static guildTemplateFromRaw(guildTemplate) {
+        return {
+            code: guildTemplate.code,
+            name: guildTemplate.name,
+            description: guildTemplate.description,
+            usageCount: guildTemplate.usage_count,
+            creatorID: guildTemplate.creator_id,
+            creator: Users_1.Users.userFromRaw(guildTemplate.creator),
+            createdAt: guildTemplate.created_at,
+            updatedAt: guildTemplate.updated_at,
+            sourceGuildID: guildTemplate.source_guild_id,
+            serializedSourceGuild: Guilds_1.Guilds.guildFromRaw(guildTemplate.serialized_source_guild),
+            isDirty: guildTemplate.is_dirty,
+        };
+    }
+    static guildTemplateToRaw(guildTemplate) {
+        return {
+            code: guildTemplate.code,
+            name: guildTemplate.name,
+            description: guildTemplate.description,
+            usage_count: guildTemplate.usageCount,
+            creator_id: guildTemplate.creatorID,
+            creator: Users_1.Users.userToRaw(guildTemplate.creator),
+            created_at: guildTemplate.createdAt,
+            updated_at: guildTemplate.updatedAt,
+            source_guild_id: guildTemplate.sourceGuildID,
+            serialized_source_guild: Guilds_1.Guilds.guildToRaw(guildTemplate.serializedSourceGuild),
+            is_dirty: guildTemplate.isDirty,
+        };
+    }
+}
+exports.GuildTemplates = GuildTemplates;

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

@@ -0,0 +1,12 @@
+import type { RawGuildApplicationCommandPermissions, GuildApplicationCommandPermissions } from "../types/application-command";
+import type { RawGuild, Guild, RawGuildMember, GuildMember, RawIntegration, Integration } from "../types/guild";
+export declare class Guilds {
+    static guildApplicationCommandPermissionsFromRaw(guildApplicationCommandPermissions: RawGuildApplicationCommandPermissions): GuildApplicationCommandPermissions;
+    static guildApplicationCommandPermissionsToRaw(guildApplicationCommandPermissions: GuildApplicationCommandPermissions): RawGuildApplicationCommandPermissions;
+    static guildFromRaw(guild: RawGuild): Guild;
+    static guildMemberFromRaw(guildMember: RawGuildMember): GuildMember;
+    static guildMemberToRaw(guildMember: GuildMember): RawGuildMember;
+    static guildToRaw(guild: Guild): RawGuild;
+    static integrationFromRaw(integration: RawIntegration): Integration;
+    static integrationToRaw(integration: Integration): RawIntegration;
+}

package/dist/lib/transformers/Guilds.js

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Guilds = void 0;
+const Emojis_1 = require("./Emojis");
+const Roles_1 = require("./Roles");
+const Stickers_1 = require("./Stickers");
+const Users_1 = require("./Users");
+class Guilds {
+    static guildApplicationCommandPermissionsFromRaw(guildApplicationCommandPermissions) {
+        return {
+            id: guildApplicationCommandPermissions.id,
+            applicationID: guildApplicationCommandPermissions.application_id,
+            guildID: guildApplicationCommandPermissions.guild_id,
+            permissions: guildApplicationCommandPermissions.permissions.map((permission) => ({
+                id: permission.id,
+                type: permission.type,
+                permission: permission.permission,
+            })),
+        };
+    }
+    static guildApplicationCommandPermissionsToRaw(guildApplicationCommandPermissions) {
+        return {
+            id: guildApplicationCommandPermissions.id,
+            application_id: guildApplicationCommandPermissions.applicationID,
+            guild_id: guildApplicationCommandPermissions.guildID,
+            permissions: guildApplicationCommandPermissions.permissions.map((permission) => ({
+                id: permission.id,
+                type: permission.type,
+                permission: permission.permission,
+            })),
+        };
+    }
+    static guildFromRaw(guild) {
+        return {
+            id: guild.id,
+            name: guild.name,
+            icon: guild.icon,
+            iconHash: guild.icon,
+            splash: guild.splash,
+            discoverySplash: guild.discovery_splash,
+            owner: guild.owner,
+            ownerID: guild.owner_id,
+            permissions: guild.permissions,
+            region: guild.region,
+            afkChannelID: guild.afk_channel_id,
+            afkTimeout: guild.afk_timeout,
+            widgetEnabled: guild.widget_enabled,
+            widgetChannelID: guild.widget_channel_id,
+            verificationLevel: guild.verification_level,
+            defaultMessageNotifications: guild.default_message_notifications,
+            explicitContentFilter: guild.explicit_content_filter,
+            roles: guild.roles.map((role) => Roles_1.Roles.roleFromRaw(role)),
+            emojis: guild.emojis.map((emoji) => Emojis_1.Emojis.emojiFromRaw(emoji)),
+            features: guild.features,
+            mfaLevel: guild.mfa_level,
+            applicationID: guild.application_id,
+            systemChannelID: guild.system_channel_id,
+            systemChannelFlags: guild.system_channel_flags,
+            rulesChannelID: guild.rules_channel_id,
+            maxPresences: guild.max_presences,
+            maxMembers: guild.max_members,
+            vanityURLCode: guild.vanity_url_code,
+            description: guild.description,
+            banner: guild.banner,
+            premiumTier: guild.premium_tier,
+            premiumSubscriptionCount: guild.premium_subscription_count,
+            preferredLocale: guild.preferred_locale,
+            publicUpdatesChannelID: guild.public_updates_channel_id,
+            maxVideoChannelUsers: guild.max_video_channel_users,
+            maxStageVideoChannelUsers: guild.max_stage_video_channel_users,
+            approximateMemberCount: guild.approximate_member_count,
+            approximatePresenceCount: guild.approximate_presence_count,
+            welcomeScreen: guild.welcome_screen !== undefined
+                ? {
+                    description: guild.welcome_screen.description,
+                    welcomeChannels: guild.welcome_screen.welcome_channels.map((welcomeScreenChannel) => ({
+                        channelID: welcomeScreenChannel.channel_id,
+                        description: welcomeScreenChannel.description,
+                        emojiID: welcomeScreenChannel.emoji_id,
+                        emojiName: welcomeScreenChannel.emoji_name,
+                    })),
+                }
+                : undefined,
+            nsfwLevel: guild.nsfw_level,
+            stickers: guild.stickers?.map((sticker) => Stickers_1.Stickers.stickerFromRaw(sticker)),
+            premiumProgressBarEnabled: guild.premium_progress_bar_enabled,
+            safetyAlertsChannelID: guild.safety_alerts_channel_id,
+        };
+    }
+    static guildMemberFromRaw(guildMember) {
+        return {
+            user: guildMember.user !== undefined
+                ? Users_1.Users.userFromRaw(guildMember.user)
+                : undefined,
+            nick: guildMember.nick,
+            avatar: guildMember.avatar,
+            roles: guildMember.roles,
+            joinedAt: guildMember.joined_at,
+            premiumSince: guildMember.premium_since,
+            deaf: guildMember.deaf,
+            mute: guildMember.mute,
+            flags: guildMember.flags,
+            pending: guildMember.pending,
+            permissions: guildMember.permissions,
+            communicationDisabledUntil: guildMember.communication_disabled_until,
+        };
+    }
+    static guildMemberToRaw(guildMember) {
+        return {
+            user: guildMember.user !== undefined
+                ? Users_1.Users.userToRaw(guildMember.user)
+                : undefined,
+            nick: guildMember.nick,
+            avatar: guildMember.avatar,
+            roles: guildMember.roles,
+            joined_at: guildMember.joinedAt,
+            premium_since: guildMember.premiumSince,
+            deaf: guildMember.deaf,
+            mute: guildMember.mute,
+            flags: guildMember.flags,
+            pending: guildMember.pending,
+            permissions: guildMember.permissions,
+            communication_disabled_until: guildMember.communicationDisabledUntil,
+        };
+    }
+    static guildToRaw(guild) {
+        return {
+            id: guild.id,
+            name: guild.name,
+            icon: guild.icon,
+            icon_hash: guild.icon,
+            splash: guild.splash,
+            discovery_splash: guild.discoverySplash,
+            owner: guild.owner,
+            owner_id: guild.ownerID,
+            permissions: guild.permissions,
+            region: guild.region,
+            afk_channel_id: guild.afkChannelID,
+            afk_timeout: guild.afkTimeout,
+            widget_enabled: guild.widgetEnabled,
+            widget_channel_id: guild.widgetChannelID,
+            verification_level: guild.verificationLevel,
+            default_message_notifications: guild.defaultMessageNotifications,
+            explicit_content_filter: guild.explicitContentFilter,
+            roles: guild.roles.map((role) => Roles_1.Roles.roleToRaw(role)),
+            emojis: guild.emojis.map((emoji) => Emojis_1.Emojis.emojiToRaw(emoji)),
+            features: guild.features,
+            mfa_level: guild.mfaLevel,
+            application_id: guild.applicationID,
+            system_channel_id: guild.systemChannelID,
+            system_channel_flags: guild.systemChannelFlags,
+            rules_channel_id: guild.rulesChannelID,
+            max_presences: guild.maxPresences,
+            max_members: guild.maxMembers,
+            vanity_url_code: guild.vanityURLCode,
+            description: guild.description,
+            banner: guild.banner,
+            premium_tier: guild.premiumTier,
+            premium_subscription_count: guild.premiumSubscriptionCount,
+            preferred_locale: guild.preferredLocale,
+            public_updates_channel_id: guild.publicUpdatesChannelID,
+            max_video_channel_users: guild.maxVideoChannelUsers,
+            max_stage_video_channel_users: guild.maxStageVideoChannelUsers,
+            approximate_member_count: guild.approximateMemberCount,
+            approximate_presence_count: guild.approximatePresenceCount,
+            welcome_screen: guild.welcomeScreen !== undefined
+                ? {
+                    description: guild.welcomeScreen.description,
+                    welcome_channels: guild.welcomeScreen.welcomeChannels.map((welcomeScreenChannel) => ({
+                        channel_id: welcomeScreenChannel.channelID,
+                        description: welcomeScreenChannel.description,
+                        emoji_id: welcomeScreenChannel.emojiID,
+                        emoji_name: welcomeScreenChannel.emojiName,
+                    })),
+                }
+                : undefined,
+            nsfw_level: guild.nsfwLevel,
+            stickers: guild.stickers?.map((sticker) => Stickers_1.Stickers.stickerToRaw(sticker)),
+            premium_progress_bar_enabled: guild.premiumProgressBarEnabled,
+            safety_alerts_channel_id: guild.safetyAlertsChannelID,
+        };
+    }
+    static integrationFromRaw(integration) {
+        return {
+            id: integration.id,
+            name: integration.name,
+            type: integration.type,
+            enabled: integration.enabled,
+            syncing: integration.syncing,
+            roleID: integration.role_id,
+            enableEmoticons: integration.enable_emoticons,
+            expireBehavior: integration.expire_behavior,
+            expireGracePeriod: integration.expire_grace_period,
+            user: integration.user !== undefined
+                ? Users_1.Users.userFromRaw(integration.user)
+                : undefined,
+            account: integration.account,
+            syncedAt: integration.synced_at,
+            subscriberCount: integration.subscriber_count,
+            revoked: integration.revoked,
+            application: integration.application !== undefined
+                ? {
+                    id: integration.application.id,
+                    name: integration.application.name,
+                    icon: integration.application.icon,
+                    description: integration.application.description,
+                    bot: integration.application.bot !== undefined
+                        ? Users_1.Users.userFromRaw(integration.application.bot)
+                        : undefined,
+                }
+                : undefined,
+            scopes: integration.scopes,
+        };
+    }
+    static integrationToRaw(integration) {
+        return {
+            id: integration.id,
+            name: integration.name,
+            type: integration.type,
+            enabled: integration.enabled,
+            syncing: integration.syncing,
+            role_id: integration.roleID,
+            enable_emoticons: integration.enableEmoticons,
+            expire_behavior: integration.expireBehavior,
+            expire_grace_period: integration.expireGracePeriod,
+            user: integration.user !== undefined
+                ? Users_1.Users.userToRaw(integration.user)
+                : undefined,
+            account: integration.account,
+            synced_at: integration.syncedAt,
+            subscriber_count: integration.subscriberCount,
+            revoked: integration.revoked,
+            application: integration.application !== undefined
+                ? {
+                    id: integration.application.id,
+                    name: integration.application.name,
+                    icon: integration.application.icon,
+                    description: integration.application.description,
+                    bot: integration.application.bot !== undefined
+                        ? Users_1.Users.userToRaw(integration.application.bot)
+                        : undefined,
+                }
+                : undefined,
+            scopes: integration.scopes,
+        };
+    }
+}
+exports.Guilds = Guilds;

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

@@ -0,0 +1,10 @@
+import type { RawMessageInteractionMetadata, MessageInteractionMetadata } from "../types/channel";
+import type { RawInteraction, Interaction, RawResolvedData, ResolvedData } from "../types/interaction";
+export declare class Interactions {
+    static interactionFromRaw(interaction: RawInteraction): Interaction;
+    static interactionMetadataFromRaw(interactionMetadata: RawMessageInteractionMetadata): MessageInteractionMetadata;
+    static interactionMetadataToRaw(interactionMetadata: MessageInteractionMetadata): RawMessageInteractionMetadata;
+    static interactionToRaw(interaction: Interaction): RawInteraction;
+    static resolvedDataFromRaw(resolvedData: RawResolvedData): ResolvedData;
+    static resolvedDataToRaw(resolvedData: ResolvedData): RawResolvedData;
+}