disgroove 2.2.2-dev.db6cb16 → 2.2.3-dev.4f98e3d

package/dist/lib/transformers/Interactions.js

@@ -0,0 +1,273 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interactions = void 0;
+const Channels_1 = require("./Channels");
+const Guilds_1 = require("./Guilds");
+const Users_1 = require("./Users");
+const Entitlements_1 = require("./Entitlements");
+const Roles_1 = require("./Roles");
+class Interactions {
+    static interactionFromRaw(interaction) {
+        return {
+            id: interaction.id,
+            applicationID: interaction.application_id,
+            type: interaction.type,
+            data: interaction.data !== undefined
+                ? {
+                    id: interaction.data.id,
+                    name: interaction.data.name,
+                    type: interaction.data.type,
+                    resolved: interaction.data.resolved !== undefined
+                        ? Interactions.resolvedDataFromRaw(interaction.data.resolved)
+                        : undefined,
+                    options: interaction.data.options,
+                    guildID: interaction.data.guild_id,
+                    targetID: interaction.data.target_id,
+                    customID: interaction.data.custom_id,
+                    componentType: interaction.data.component_type,
+                    values: interaction.data.values,
+                    components: interaction.data.components?.map((component) => ({
+                        type: component.type,
+                        components: component.components?.map((c) => ({
+                            type: c.type,
+                            customID: c.custom_id,
+                            style: c.style,
+                            label: c.label,
+                            minLength: c.min_length,
+                            maxLength: c.max_length,
+                            required: c.required,
+                            value: c.value,
+                            placeholder: c.placeholder,
+                        })),
+                    })),
+                }
+                : undefined,
+            guild: interaction.guild !== undefined
+                ? {
+                    locale: interaction.guild.locale,
+                    id: interaction.guild.id,
+                    features: interaction.guild.features,
+                }
+                : undefined,
+            guildID: interaction.guild_id,
+            channel: interaction.channel !== undefined
+                ? Channels_1.Channels.channelFromRaw(interaction.channel)
+                : undefined,
+            channelID: interaction.channel_id,
+            member: interaction.member !== undefined
+                ? Guilds_1.Guilds.guildMemberFromRaw(interaction.member)
+                : undefined,
+            user: interaction.user !== undefined
+                ? Users_1.Users.userFromRaw(interaction.user)
+                : undefined,
+            token: interaction.token,
+            version: interaction.version,
+            message: interaction.message !== undefined
+                ? Channels_1.Channels.messageFromRaw(interaction.message)
+                : undefined,
+            appPermissions: interaction.app_permissions,
+            locale: interaction.locale,
+            guildLocale: interaction.guild_locale,
+            entitlements: interaction.entitlements.map((entitlement) => Entitlements_1.Entitlements.entitlementFromRaw(entitlement)),
+            authorizingIntegrationOwners: {
+                "0": interaction.authorizing_integration_owners[0],
+                "1": interaction.authorizing_integration_owners[1],
+            },
+            context: interaction.context,
+        };
+    }
+    static interactionMetadataFromRaw(interactionMetadata) {
+        return {
+            id: interactionMetadata.id,
+            type: interactionMetadata.type,
+            user: Users_1.Users.userFromRaw(interactionMetadata.user),
+            authorizingIntegrationOwners: {
+                "0": interactionMetadata.authorizing_integration_owners[0],
+                "1": interactionMetadata.authorizing_integration_owners[1],
+            },
+            originalResponseMessageID: interactionMetadata.original_response_message_id,
+            interactedMessageID: interactionMetadata.interacted_message_id,
+            triggeringInteractionMetadata: interactionMetadata.triggering_interaction_metadata !== undefined
+                ? Interactions.interactionMetadataFromRaw(interactionMetadata.triggering_interaction_metadata)
+                : undefined,
+        };
+    }
+    static interactionMetadataToRaw(interactionMetadata) {
+        return {
+            id: interactionMetadata.id,
+            type: interactionMetadata.type,
+            user: Users_1.Users.userToRaw(interactionMetadata.user),
+            authorizing_integration_owners: {
+                "0": interactionMetadata.authorizingIntegrationOwners[0],
+                "1": interactionMetadata.authorizingIntegrationOwners[1],
+            },
+            original_response_message_id: interactionMetadata.originalResponseMessageID,
+            interacted_message_id: interactionMetadata.interactedMessageID,
+            triggering_interaction_metadata: interactionMetadata.triggeringInteractionMetadata !== undefined
+                ? Interactions.interactionMetadataToRaw(interactionMetadata.triggeringInteractionMetadata)
+                : undefined,
+        };
+    }
+    static interactionToRaw(interaction) {
+        return {
+            id: interaction.id,
+            application_id: interaction.applicationID,
+            type: interaction.type,
+            data: interaction.data !== undefined
+                ? {
+                    id: interaction.data.id,
+                    name: interaction.data.name,
+                    type: interaction.data.type,
+                    resolved: interaction.data.resolved !== undefined
+                        ? Interactions.resolvedDataToRaw(interaction.data.resolved)
+                        : undefined,
+                    options: interaction.data.options,
+                    guild_id: interaction.data.guildID,
+                    target_id: interaction.data.targetID,
+                    custom_id: interaction.data.customID,
+                    component_type: interaction.data.componentType,
+                    values: interaction.data.values,
+                    components: interaction.data.components?.map((component) => ({
+                        type: component.type,
+                        components: component.components?.map((c) => ({
+                            type: c.type,
+                            custom_id: c.customID,
+                            style: c.style,
+                            label: c.label,
+                            min_length: c.minLength,
+                            max_length: c.maxLength,
+                            required: c.required,
+                            value: c.value,
+                            placeholder: c.placeholder,
+                        })),
+                    })),
+                }
+                : undefined,
+            guild: interaction.guild !== undefined
+                ? {
+                    locale: interaction.guild.locale,
+                    id: interaction.guild.id,
+                    features: interaction.guild.features,
+                }
+                : undefined,
+            guild_id: interaction.guildID,
+            channel: interaction.channel !== undefined
+                ? Channels_1.Channels.channelToRaw(interaction.channel)
+                : undefined,
+            channel_id: interaction.channelID,
+            member: interaction.member !== undefined
+                ? Guilds_1.Guilds.guildMemberToRaw(interaction.member)
+                : undefined,
+            user: interaction.user !== undefined
+                ? Users_1.Users.userToRaw(interaction.user)
+                : undefined,
+            token: interaction.token,
+            version: interaction.version,
+            message: interaction.message !== undefined
+                ? Channels_1.Channels.messageToRaw(interaction.message)
+                : undefined,
+            app_permissions: interaction.appPermissions,
+            locale: interaction.locale,
+            guild_locale: interaction.guildLocale,
+            entitlements: interaction.entitlements.map((entitlement) => Entitlements_1.Entitlements.entitlementToRaw(entitlement)),
+            authorizing_integration_owners: {
+                "0": interaction.authorizingIntegrationOwners[0],
+                "1": interaction.authorizingIntegrationOwners[1],
+            },
+            context: interaction.context,
+        };
+    }
+    static resolvedDataFromRaw(resolvedData) {
+        let users = {};
+        let members = {};
+        let roles = {};
+        let channels = {};
+        let messages = {};
+        let attachments = {};
+        if (resolvedData.users !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.users)) {
+                users[key] = Users_1.Users.userFromRaw(value);
+            }
+        }
+        if (resolvedData.members !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.members)) {
+                members[key] = Guilds_1.Guilds.guildMemberFromRaw(value);
+            }
+        }
+        if (resolvedData.roles !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.roles)) {
+                roles[key] = Roles_1.Roles.roleFromRaw(value);
+            }
+        }
+        if (resolvedData.channels !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.channels)) {
+                channels[key] = Channels_1.Channels.channelFromRaw(value);
+            }
+        }
+        if (resolvedData.messages !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.messages)) {
+                messages[key] = Channels_1.Channels.messageFromRaw(value);
+            }
+        }
+        if (resolvedData.attachments !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.attachments)) {
+                attachments[key] = Channels_1.Channels.attachmentFromRaw(value);
+            }
+        }
+        return {
+            users,
+            members,
+            roles,
+            channels,
+            messages,
+            attachments,
+        };
+    }
+    static resolvedDataToRaw(resolvedData) {
+        let users = {};
+        let members = {};
+        let roles = {};
+        let channels = {};
+        let messages = {};
+        let attachments = {};
+        if (resolvedData.users !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.users)) {
+                users[key] = Users_1.Users.userToRaw(value);
+            }
+        }
+        if (resolvedData.members !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.members)) {
+                members[key] = Guilds_1.Guilds.guildMemberToRaw(value);
+            }
+        }
+        if (resolvedData.roles !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.roles)) {
+                roles[key] = Roles_1.Roles.roleToRaw(value);
+            }
+        }
+        if (resolvedData.channels !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.channels)) {
+                channels[key] = Channels_1.Channels.channelToRaw(value);
+            }
+        }
+        if (resolvedData.messages !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.messages)) {
+                messages[key] = Channels_1.Channels.messageToRaw(value);
+            }
+        }
+        if (resolvedData.attachments !== undefined) {
+            for (const [key, value] of Object.entries(resolvedData.attachments)) {
+                attachments[key] = Channels_1.Channels.attachmentToRaw(value);
+            }
+        }
+        return {
+            users,
+            members,
+            roles,
+            channels,
+            messages,
+            attachments,
+        };
+    }
+}
+exports.Interactions = Interactions;

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

@@ -0,0 +1,5 @@
+import type { RawInvite, Invite } from "../types/invite";
+export declare class Invites {
+    static inviteFromRaw(invite: RawInvite): Invite;
+    static inviteToRaw(invite: Invite): RawInvite;
+}

package/dist/lib/transformers/Invites.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Invites = void 0;
+const Applications_1 = require("./Applications");
+const Channels_1 = require("./Channels");
+const Guilds_1 = require("./Guilds");
+const GuildScheduledEvents_1 = require("./GuildScheduledEvents");
+const Users_1 = require("./Users");
+class Invites {
+    static inviteFromRaw(invite) {
+        return {
+            type: invite.type,
+            code: invite.code,
+            guild: invite.guild !== undefined
+                ? Guilds_1.Guilds.guildFromRaw(invite.guild)
+                : undefined,
+            channel: Channels_1.Channels.channelFromRaw(invite.channel),
+            inviter: invite.inviter !== undefined
+                ? Users_1.Users.userFromRaw(invite.inviter)
+                : undefined,
+            targetType: invite.target_type,
+            targetUser: invite.target_user !== undefined
+                ? Users_1.Users.userFromRaw(invite.target_user)
+                : undefined,
+            targetApplication: invite.target_application !== undefined
+                ? Applications_1.Applications.applicationFromRaw(invite.target_application)
+                : undefined,
+            approximatePresenceCount: invite.approximate_presence_count,
+            approximateMemberCount: invite.approximate_member_count,
+            expiresAt: invite.expires_at,
+            stageInstance: invite.stage_instance !== undefined
+                ? {
+                    members: invite.stage_instance.members.map((guildMember) => Guilds_1.Guilds.guildMemberFromRaw(guildMember)),
+                    participantCount: invite.stage_instance.participant_count,
+                    speakerCount: invite.stage_instance.speaker_count,
+                    topic: invite.stage_instance.topic,
+                }
+                : undefined,
+            guildScheduledEvent: invite.guild_scheduled_event !== undefined
+                ? GuildScheduledEvents_1.GuildScheduledEvents.guildScheduledEventFromRaw(invite.guild_scheduled_event)
+                : undefined,
+        };
+    }
+    static inviteToRaw(invite) {
+        return {
+            type: invite.type,
+            code: invite.code,
+            guild: invite.guild !== undefined
+                ? Guilds_1.Guilds.guildToRaw(invite.guild)
+                : undefined,
+            channel: Channels_1.Channels.channelToRaw(invite.channel),
+            inviter: invite.inviter !== undefined
+                ? Users_1.Users.userToRaw(invite.inviter)
+                : undefined,
+            target_type: invite.targetType,
+            target_user: invite.targetUser !== undefined
+                ? Users_1.Users.userToRaw(invite.targetUser)
+                : undefined,
+            target_application: invite.targetApplication !== undefined
+                ? Applications_1.Applications.applicationToRaw(invite.targetApplication)
+                : undefined,
+            approximate_presence_count: invite.approximatePresenceCount,
+            approximate_member_count: invite.approximateMemberCount,
+            expires_at: invite.expiresAt,
+            stage_instance: invite.stageInstance !== undefined
+                ? {
+                    members: invite.stageInstance.members.map((guildMember) => Guilds_1.Guilds.guildMemberToRaw(guildMember)),
+                    participant_count: invite.stageInstance.participantCount,
+                    speaker_count: invite.stageInstance.speakerCount,
+                    topic: invite.stageInstance.topic,
+                }
+                : undefined,
+            guild_scheduled_event: invite.guildScheduledEvent !== undefined
+                ? GuildScheduledEvents_1.GuildScheduledEvents.guildScheduledEventToRaw(invite.guildScheduledEvent)
+                : undefined,
+        };
+    }
+}
+exports.Invites = Invites;

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

@@ -0,0 +1,5 @@
+import type { RawPoll, Poll } from "../types/poll";
+export declare class Polls {
+    static pollFromRaw(poll: RawPoll): Poll;
+    static pollToRaw(poll: Poll): RawPoll;
+}

package/dist/lib/transformers/Polls.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Polls = void 0;
+class Polls {
+    static pollFromRaw(poll) {
+        return {
+            question: poll.question,
+            answers: poll.answers.map((answer) => ({
+                answerID: answer.answer_id,
+                pollMedia: answer.poll_media,
+            })),
+            expiry: poll.expiry,
+            allowMultiselect: poll.allow_multiselect,
+            layoutType: poll.layout_type,
+            results: poll.results !== undefined
+                ? {
+                    isFinalized: poll.results.is_finalized,
+                    answerCounts: poll.results.answer_counts.map((answerCount) => ({
+                        id: answerCount.id,
+                        count: answerCount.count,
+                        meVoted: answerCount.me_voted,
+                    })),
+                }
+                : undefined,
+        };
+    }
+    static pollToRaw(poll) {
+        return {
+            question: poll.question,
+            answers: poll.answers.map((answer) => ({
+                answer_id: answer.answerID,
+                poll_media: answer.pollMedia,
+            })),
+            expiry: poll.expiry,
+            allow_multiselect: poll.allowMultiselect,
+            layout_type: poll.layoutType,
+            results: poll.results !== undefined
+                ? {
+                    is_finalized: poll.results.isFinalized,
+                    answer_counts: poll.results.answerCounts.map((answerCount) => ({
+                        id: answerCount.id,
+                        count: answerCount.count,
+                        me_voted: answerCount.meVoted,
+                    })),
+                }
+                : undefined,
+        };
+    }
+}
+exports.Polls = Polls;

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

@@ -0,0 +1,5 @@
+import type { RawPresenceUpdateEventFields, PresenceUpdateEventFields } from "../types/gateway-events";
+export declare class Presences {
+    static presenceFromRaw(presence: RawPresenceUpdateEventFields): PresenceUpdateEventFields;
+    static presenceToRaw(presence: PresenceUpdateEventFields): RawPresenceUpdateEventFields;
+}

package/dist/lib/transformers/Presences.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Presences = void 0;
+class Presences {
+    static presenceFromRaw(presence) {
+        return {
+            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) => ({
+                name: activity.name,
+                type: activity.type,
+                url: activity.url,
+                createdAt: activity.created_at,
+                timestamps: activity.timestamps,
+                applicationID: activity.application_id,
+                details: activity.details,
+                state: activity.state,
+                emoji: activity.emoji,
+                party: activity.party,
+                assets: {
+                    largeImage: activity.assets?.large_image,
+                    largeText: activity.assets?.large_text,
+                    smallImage: activity.assets?.small_image,
+                    smallText: activity.assets?.small_text,
+                },
+                secrets: activity.secrets,
+                instance: activity.instance,
+                flags: activity.flags,
+                buttons: activity.buttons,
+            })),
+            clientStatus: presence.client_status,
+        };
+    }
+    static presenceToRaw(presence) {
+        return {
+            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) => ({
+                name: activity.name,
+                type: activity.type,
+                url: activity.url,
+                created_at: activity.createdAt,
+                timestamps: activity.timestamps,
+                application_id: activity.applicationID,
+                details: activity.details,
+                state: activity.state,
+                emoji: activity.emoji,
+                party: activity.party,
+                assets: {
+                    large_image: activity.assets?.largeImage,
+                    large_text: activity.assets?.largeText,
+                    small_image: activity.assets?.smallImage,
+                    small_text: activity.assets?.smallText,
+                },
+                secrets: activity.secrets,
+                instance: activity.instance,
+                flags: activity.flags,
+                buttons: activity.buttons,
+            })),
+            client_status: presence.clientStatus,
+        };
+    }
+}
+exports.Presences = Presences;

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

@@ -0,0 +1,5 @@
+import type { RawRole, Role } from "../types/role";
+export declare class Roles {
+    static roleFromRaw(role: RawRole): Role;
+    static roleToRaw(role: Role): RawRole;
+}

package/dist/lib/transformers/Roles.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Roles = void 0;
+class Roles {
+    static roleFromRaw(role) {
+        return {
+            id: role.id,
+            name: role.name,
+            color: role.color,
+            hoist: role.hoist,
+            icon: role.icon,
+            unicodeEmoji: role.unicode_emoji,
+            position: role.position,
+            permissions: role.permissions,
+            managed: role.managed,
+            mentionable: role.mentionable,
+            tags: role.tags !== undefined
+                ? {
+                    botID: role.tags.bot_id,
+                    integrationID: role.tags.integration_id,
+                    premiumSubscriber: role.tags.premium_subscriber,
+                    subscriptionListingID: role.tags.subscription_listing_id,
+                    availableForPurchase: role.tags.available_for_purchase,
+                    guildConnections: role.tags.guild_connections,
+                }
+                : undefined,
+            flags: role.flags,
+        };
+    }
+    static roleToRaw(role) {
+        return {
+            id: role.id,
+            name: role.name,
+            color: role.color,
+            hoist: role.hoist,
+            icon: role.icon,
+            unicode_emoji: role.unicodeEmoji,
+            position: role.position,
+            permissions: role.permissions,
+            managed: role.managed,
+            mentionable: role.mentionable,
+            tags: role.tags !== undefined
+                ? {
+                    bot_id: role.tags.botID,
+                    integration_id: role.tags.integrationID,
+                    premium_subscriber: role.tags.premiumSubscriber,
+                    subscription_listing_id: role.tags.subscriptionListingID,
+                    available_for_purchase: role.tags.availableForPurchase,
+                    guild_connections: role.tags.guildConnections,
+                }
+                : undefined,
+            flags: role.flags,
+        };
+    }
+}
+exports.Roles = Roles;

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

@@ -0,0 +1,5 @@
+import type { RawSKU, SKU } from "../types/sku";
+export declare class SKUs {
+    static skuFromRaw(sku: RawSKU): SKU;
+    static skuToRaw(sku: SKU): RawSKU;
+}

package/dist/lib/transformers/SKUs.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SKUs = void 0;
+class SKUs {
+    static skuFromRaw(sku) {
+        return {
+            id: sku.id,
+            type: sku.type,
+            applicationID: sku.application_id,
+            name: sku.name,
+            slug: sku.slug,
+            flags: sku.flags,
+        };
+    }
+    static skuToRaw(sku) {
+        return {
+            id: sku.id,
+            type: sku.type,
+            application_id: sku.applicationID,
+            name: sku.name,
+            slug: sku.slug,
+            flags: sku.flags,
+        };
+    }
+}
+exports.SKUs = SKUs;

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

@@ -0,0 +1,5 @@
+import type { RawStageInstance, StageInstance } from "../types/stage-instance";
+export declare class StageInstances {
+    static stageInstanceFromRaw(stageInstance: RawStageInstance): StageInstance;
+    static stageInstanceToRaw(stageInstance: StageInstance): RawStageInstance;
+}

package/dist/lib/transformers/StageInstances.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StageInstances = void 0;
+class StageInstances {
+    static stageInstanceFromRaw(stageInstance) {
+        return {
+            id: stageInstance.id,
+            guildID: stageInstance.guild_id,
+            channelID: stageInstance.channel_id,
+            topic: stageInstance.topic,
+            privacyLevel: stageInstance.privacy_level,
+            discoverableDisabled: stageInstance.discoverable_disabled,
+            guildScheduledEventID: stageInstance.guild_scheduled_event_id,
+        };
+    }
+    static stageInstanceToRaw(stageInstance) {
+        return {
+            id: stageInstance.id,
+            guild_id: stageInstance.guildID,
+            channel_id: stageInstance.channelID,
+            topic: stageInstance.topic,
+            privacy_level: stageInstance.privacyLevel,
+            discoverable_disabled: stageInstance.discoverableDisabled,
+            guild_scheduled_event_id: stageInstance.guildScheduledEventID,
+        };
+    }
+}
+exports.StageInstances = StageInstances;

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

@@ -0,0 +1,5 @@
+import type { RawSticker, Sticker } from "../types/sticker";
+export declare class Stickers {
+    static stickerFromRaw(sticker: RawSticker): Sticker;
+    static stickerToRaw(sticker: Sticker): RawSticker;
+}