elynn-baileys 1.0.1

package/lib/Discord/util/Util.cjs

@@ -0,0 +1,906 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/** @module Util */
+const Routes_1 = require("./Routes.cjs");
+const Errors_1 = require("./Errors.cjs");
+const Constants_1 = require("../Constants.cjs");
+const Member_1 = __importDefault(require("../structures/Member.cjs"));
+const Channel_1 = __importDefault(require("../structures/Channel.cjs"));
+const Message_1 = __importDefault(require("../structures/Message.cjs"));
+const Entitlement_1 = __importDefault(require("../structures/Entitlement.cjs"));
+const TestEntitlement_1 = __importDefault(require("../structures/TestEntitlement.cjs"));
+const node_util_1 = require("node:util");
+/** A general set of utilities. These are intentionally poorly documented, as they serve almost no usefulness to outside developers. */
+class Util {
+    _client;
+    constructor(client) {
+        this._client = client;
+    }
+    static rawEmbeds(embeds) {
+        const data = Util.prototype.embedsToParsed(Array.isArray(embeds) ? embeds : [embeds]);
+        return Array.isArray(embeds) ? data : data[0];
+    }
+    static rawMessageComponents(components) {
+        const data = Util.prototype.componentsToParsed(Array.isArray(components) ? components : [components]);
+        return Array.isArray(components) ? data : data[0];
+    }
+    static rawModalComponents(components) {
+        const data = Util.prototype.componentsToParsed(Array.isArray(components) ? components : [components]);
+        return Array.isArray(components) ? data : data[0];
+    }
+    /** @hidden intentionally not documented - this is an internal function */
+    _arrayToCSV(data, header) {
+        return Buffer.from([header, ...data].filter(Boolean).join("\n"), "utf8");
+    }
+    /** @hidden intentionally not documented - this is an internal function */
+    _arrayToCSVFile(data, name, header) {
+        return {
+            name: `${name}.csv`,
+            field: name,
+            contents: this._arrayToCSV(data, header)
+        };
+    }
+    /** @hidden intentionally not documented - this is an internal function */
+    _convertImage(image, name) {
+        try {
+            return this.convertImage(image);
+        }
+        catch (err) {
+            throw new TypeError(`Invalid ${name} provided. Ensure you are providing a valid, fully-qualified base64 url.`, { cause: err });
+        }
+    }
+    /** @hidden intended for internal use only */
+    _convertSound(sound, name) {
+        try {
+            return this.convertSound(sound);
+        }
+        catch (err) {
+            throw new TypeError(`Invalid ${name} provided. Ensure you are providing a valid, fully-qualified base64 url.`, { cause: err });
+        }
+    }
+    /** @internal */
+    _freeze(obj, detail) {
+        let message = "This is an error in the library and should be reported.";
+        if (detail) {
+            message += `Detail: ${detail}`;
+        }
+        if (typeof obj !== "object" || obj === null || node_util_1.types.isProxy(obj)) {
+            return obj;
+        }
+        return new Proxy(obj, {
+            set: (target, prop, value, receiver) => {
+                this._client.emit("error", new Errors_1.FrozenModificationError(message, prop));
+                return Reflect.set(target, prop, value, receiver);
+            }
+        });
+    }
+    /** @hidden intended for internal use only */
+    _getLimit(name, id) {
+        const opt = this._client.options.collectionLimits[name];
+        if (typeof opt === "number") {
+            return opt;
+        }
+        return (id === undefined ? undefined : opt[id]) ?? opt.default ?? Infinity;
+    }
+    /** @hidden intended for internal use only */
+    _isModuleInstalled(name) {
+        try {
+            // eslint-disable-next-line unicorn/prefer-module
+            require(name);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    _setLimit(values, defaultValue = Infinity) {
+        if (values === undefined) {
+            return defaultValue;
+        }
+        if (typeof values === "object") {
+            return { default: defaultValue, ...values };
+        }
+        return values;
+    }
+    componentToParsed(component) {
+        switch (component.type) {
+            case Constants_1.ComponentTypes.ACTION_ROW: {
+                return {
+                    components: component.components.map(c => this.componentToParsed(c)),
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.BUTTON: {
+                if (component.style === Constants_1.ButtonStyles.LINK)
+                    return component;
+                if (component.style === Constants_1.ButtonStyles.PREMIUM) {
+                    return {
+                        disabled: component.disabled,
+                        skuID: component.sku_id,
+                        style: component.style,
+                        type: component.type
+                    };
+                }
+                return {
+                    customID: component.custom_id,
+                    disabled: component.disabled,
+                    emoji: component.emoji,
+                    label: component.label,
+                    style: component.style,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.TEXT_INPUT: {
+                return {
+                    customID: component.custom_id,
+                    label: component.label,
+                    maxLength: component.max_length,
+                    minLength: component.min_length,
+                    placeholder: component.placeholder,
+                    required: component.required,
+                    style: component.style,
+                    type: component.type,
+                    value: component.value
+                };
+            }
+            case Constants_1.ComponentTypes.STRING_SELECT:
+            case Constants_1.ComponentTypes.USER_SELECT:
+            case Constants_1.ComponentTypes.ROLE_SELECT:
+            case Constants_1.ComponentTypes.MENTIONABLE_SELECT:
+            case Constants_1.ComponentTypes.CHANNEL_SELECT: {
+                const parsedComponent = {
+                    customID: component.custom_id,
+                    disabled: component.disabled,
+                    maxValues: component.max_values,
+                    minValues: component.min_values,
+                    placeholder: component.placeholder,
+                    type: component.type
+                };
+                if (component.type !== Constants_1.ComponentTypes.STRING_SELECT && component.default_values !== undefined) {
+                    parsedComponent.defaultValues = component.default_values;
+                }
+                if (component.type === Constants_1.ComponentTypes.STRING_SELECT) {
+                    return { ...parsedComponent, options: component.options };
+                }
+                else if (component.type === Constants_1.ComponentTypes.CHANNEL_SELECT) {
+                    return { ...parsedComponent, channelTypes: component.channel_types };
+                }
+                else {
+                    return parsedComponent;
+                }
+            }
+            case Constants_1.ComponentTypes.TEXT_DISPLAY: {
+                return component;
+            }
+            case Constants_1.ComponentTypes.THUMBNAIL: {
+                return {
+                    description: component.description,
+                    media: {
+                        attachmentID: component.media.attachment_id,
+                        contentType: component.media.content_type,
+                        height: component.media.height,
+                        proxyURL: component.media.proxy_url,
+                        url: component.media.url,
+                        width: component.media.width
+                    },
+                    spoiler: component.spoiler,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.MEDIA_GALLERY: {
+                return {
+                    items: component.items.map(i => ({
+                        description: i.description,
+                        media: {
+                            attachmentID: i.media.attachment_id,
+                            contentType: i.media.content_type,
+                            height: i.media.height,
+                            proxyURL: i.media.proxy_url,
+                            url: i.media.url,
+                            width: i.media.width
+                        },
+                        spoiler: i.spoiler
+                    })),
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.FILE: {
+                return {
+                    file: {
+                        attachmentID: component.file.attachment_id,
+                        contentType: component.file.content_type,
+                        height: component.file.height,
+                        proxyURL: component.file.proxy_url,
+                        url: component.file.url,
+                        width: component.file.width
+                    },
+                    spoiler: component.spoiler,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.SEPARATOR: {
+                return component;
+            }
+            case Constants_1.ComponentTypes.CONTAINER: {
+                return {
+                    accentColor: component.accent_color,
+                    components: component.components.map(c => this.componentToParsed(c)),
+                    spoiler: component.spoiler,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.SECTION: {
+                return {
+                    type: component.type,
+                    accessory: component.accessory ? this.componentToParsed(component.accessory) : undefined,
+                    components: component.components.map(c => this.componentToParsed(c))
+                };
+            }
+            case Constants_1.ComponentTypes.LABEL: {
+                return {
+                    type: component.type,
+                    label: component.label,
+                    description: component.description,
+                    component: this.componentToParsed(component.component)
+                };
+            }
+            case Constants_1.ComponentTypes.FILE_UPLOAD: {
+                return {
+                    customID: component.custom_id,
+                    maxValues: component.max_values,
+                    minValues: component.min_values,
+                    required: component.required,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.RADIO_GROUP: {
+                return {
+                    customID: component.custom_id,
+                    required: component.required,
+                    options: component.options.map(o => ({
+                        default: o.default,
+                        description: o.description,
+                        label: o.label,
+                        value: o.value
+                    })),
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.CHECKBOX: {
+                return {
+                    customID: component.custom_id,
+                    default: component.default,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.CHECKBOX_GROUP: {
+                return {
+                    customID: component.custom_id,
+                    maxValues: component.max_values,
+                    minValues: component.min_values,
+                    options: component.options.map(o => ({
+                        default: o.default,
+                        description: o.description,
+                        label: o.label,
+                        value: o.value
+                    })),
+                    required: component.required,
+                    type: component.type
+                };
+            }
+            default: {
+                return component;
+            }
+        }
+    }
+    componentToRaw(component) {
+        switch (component.type) {
+            case Constants_1.ComponentTypes.ACTION_ROW: {
+                return {
+                    type: component.type,
+                    components: component.components.map(c => this.componentToRaw(c))
+                };
+            }
+            case Constants_1.ComponentTypes.BUTTON: {
+                if (component.style === Constants_1.ButtonStyles.LINK)
+                    return component;
+                if (component.style === Constants_1.ButtonStyles.PREMIUM) {
+                    return {
+                        disabled: component.disabled,
+                        sku_id: component.skuID,
+                        style: component.style,
+                        type: component.type
+                    };
+                }
+                return {
+                    custom_id: component.customID,
+                    disabled: component.disabled,
+                    emoji: component.emoji,
+                    label: component.label,
+                    style: component.style,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.TEXT_INPUT: {
+                return {
+                    custom_id: component.customID,
+                    label: component.label,
+                    max_length: component.maxLength,
+                    min_length: component.minLength,
+                    placeholder: component.placeholder,
+                    required: component.required,
+                    style: component.style,
+                    type: component.type,
+                    value: component.value
+                };
+            }
+            case Constants_1.ComponentTypes.STRING_SELECT:
+            case Constants_1.ComponentTypes.USER_SELECT:
+            case Constants_1.ComponentTypes.ROLE_SELECT:
+            case Constants_1.ComponentTypes.MENTIONABLE_SELECT:
+            case Constants_1.ComponentTypes.CHANNEL_SELECT: {
+                const rawComponent = {
+                    custom_id: component.customID,
+                    disabled: component.disabled,
+                    max_values: component.maxValues,
+                    min_values: component.minValues,
+                    placeholder: component.placeholder,
+                    required: component.required,
+                    type: component.type
+                };
+                if (component.type !== Constants_1.ComponentTypes.STRING_SELECT && component.defaultValues !== undefined) {
+                    rawComponent.default_values = component.defaultValues;
+                }
+                if (component.type === Constants_1.ComponentTypes.STRING_SELECT) {
+                    return { ...rawComponent, options: component.options };
+                }
+                else if (component.type === Constants_1.ComponentTypes.CHANNEL_SELECT) {
+                    return { ...rawComponent, channel_types: component.channelTypes };
+                }
+                else {
+                    return rawComponent;
+                }
+            }
+            case Constants_1.ComponentTypes.TEXT_DISPLAY: {
+                return component;
+            }
+            case Constants_1.ComponentTypes.THUMBNAIL: {
+                return {
+                    description: component.description,
+                    media: {
+                        attachment_id: component.media.attachmentID,
+                        content_type: component.media.contentType,
+                        height: component.media.height,
+                        proxy_url: component.media.proxyURL,
+                        url: component.media.url,
+                        width: component.media.width
+                    },
+                    spoiler: component.spoiler,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.MEDIA_GALLERY: {
+                return {
+                    items: component.items.map(i => ({
+                        description: i.description,
+                        media: {
+                            attachment_id: i.media.attachmentID,
+                            content_type: i.media.contentType,
+                            height: i.media.height,
+                            proxy_url: i.media.proxyURL,
+                            url: i.media.url,
+                            width: i.media.width
+                        },
+                        spoiler: i.spoiler
+                    })),
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.FILE: {
+                return {
+                    file: {
+                        attachment_id: component.file.attachmentID,
+                        content_type: component.file.contentType,
+                        height: component.file.height,
+                        proxy_url: component.file.proxyURL,
+                        url: component.file.url,
+                        width: component.file.width
+                    },
+                    spoiler: component.spoiler,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.SEPARATOR: {
+                return component;
+            }
+            case Constants_1.ComponentTypes.CONTAINER: {
+                return {
+                    accent_color: component.accentColor,
+                    components: component.components.map(c => this.componentToRaw(c)),
+                    spoiler: component.spoiler,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.SECTION: {
+                return {
+                    type: component.type,
+                    accessory: component.accessory ? this.componentToRaw(component.accessory) : undefined,
+                    components: component.components.map(c => this.componentToRaw(c))
+                };
+            }
+            case Constants_1.ComponentTypes.LABEL: {
+                return {
+                    type: component.type,
+                    label: component.label,
+                    description: component.description,
+                    component: this.componentToRaw(component.component)
+                };
+            }
+            case Constants_1.ComponentTypes.FILE_UPLOAD:
+                return {
+                    custom_id: component.customID,
+                    max_values: component.maxValues,
+                    min_values: component.minValues,
+                    required: component.required,
+                    type: component.type
+                };
+            case Constants_1.ComponentTypes.RADIO_GROUP: {
+                return {
+                    custom_id: component.customID,
+                    required: component.required,
+                    options: component.options.map(o => ({
+                        default: o.default,
+                        description: o.description,
+                        label: o.label,
+                        value: o.value
+                    })),
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.CHECKBOX: {
+                return {
+                    custom_id: component.customID,
+                    default: component.default,
+                    type: component.type
+                };
+            }
+            case Constants_1.ComponentTypes.CHECKBOX_GROUP: {
+                return {
+                    custom_id: component.customID,
+                    max_values: component.maxValues,
+                    min_values: component.minValues,
+                    options: component.options.map(o => ({
+                        default: o.default,
+                        description: o.description,
+                        label: o.label,
+                        value: o.value
+                    })),
+                    required: component.required,
+                    type: component.type
+                };
+            }
+            default: {
+                return component;
+            }
+        }
+    }
+    componentsToParsed(components) {
+        return components.map(component => this.componentToParsed(component));
+    }
+    componentsToRaw(components) {
+        return components.map(component => this.componentToRaw(component));
+    }
+    convertApplicationEmoji(raw) {
+        return this.convertGuildEmoji(raw);
+    }
+    convertGuildEmoji(raw) {
+        return {
+            animated: raw.animated,
+            available: raw.available,
+            id: raw.id,
+            managed: raw.managed,
+            name: raw.name,
+            requireColons: raw.require_colons,
+            roles: raw.roles,
+            user: raw.user ? this._client.users.update(raw.user) : undefined
+        };
+    }
+    convertImage(img) {
+        if (Buffer.isBuffer(img)) {
+            const b64 = img.toString("base64");
+            let mime;
+            const magicMap = [
+                // 47 49 46 38
+                ["image/gif", /^47494638/],
+                // 89 50 4E 47
+                ["image/png", /^89504E47/],
+                // FF D8 FF
+                ["image/jpeg", /^FFD8FF/],
+                // 52 49 46 46 ?? ?? ?? ?? 57 45 42 50
+                ["image/webp", /^52494646\d{8}57454250/],
+                // 02 27 62 20 22 0 - lottie JSON (assuming all files will start with {"v":")
+                ["application/json", /^02276220220/]
+            ];
+            for (const format of magicMap) {
+                if (format[1].test(this.getMagic(img, 16))) {
+                    mime = format[0];
+                    break;
+                }
+            }
+            if (!mime) {
+                throw new TypeError(`Failed to determine image format. (magic: ${this.getMagic(img, 16)})`);
+            }
+            img = `data:${mime};base64,${b64}`;
+        }
+        return img;
+    }
+    convertSound(audio) {
+        if (Buffer.isBuffer(audio)) {
+            const b64 = audio.toString("base64");
+            let mime;
+            const magicMap = [
+                // 49 44 33
+                ["audio/mpeg", /^494433/],
+                // FF FB
+                ["audio/mpeg", /^FFFB/],
+                // 4F 67 67 53
+                ["audio/ogg", /^4F676753/]
+            ];
+            for (const format of magicMap) {
+                if (format[1].test(this.getMagic(audio, 16))) {
+                    mime = format[0];
+                    break;
+                }
+            }
+            if (!mime) {
+                throw new TypeError(`Failed to determine sound format. (magic: ${this.getMagic(audio, 16)})`);
+            }
+            audio = `data:${mime};base64,${b64}`;
+        }
+        return audio;
+    }
+    convertSticker(raw) {
+        return {
+            asset: raw.asset,
+            available: raw.available,
+            description: raw.description,
+            formatType: raw.format_type,
+            guildID: raw.guild_id,
+            id: raw.id,
+            name: raw.name,
+            packID: raw.pack_id,
+            sortValue: raw.sort_value,
+            tags: raw.tags,
+            type: raw.type,
+            user: raw.user ? this._client.users.update(raw.user) : undefined
+        };
+    }
+    async detectMissingPrivilegedIntents(intents) {
+        const application = this._client["_application"] || await this._client.rest.applications.getClient();
+        intents ??= this._client.shards.options.intents;
+        this._client["_application"] ??= application;
+        const missing = [];
+        const check = (intent, allowed) => {
+            if ((intents & intent) === intent && !allowed.some(flag => (application.flags & flag) === flag)) {
+                missing.push(Constants_1.Intents[intent]);
+            }
+        };
+        for (const [intent, allowed] of Constants_1.PrivilegedIntentMapping) {
+            check(intent, allowed);
+        }
+        return missing;
+    }
+    embedsToParsed(embeds) {
+        return embeds.map(embed => ({
+            author: embed.author === undefined ? undefined : {
+                name: embed.author.name,
+                iconURL: embed.author.icon_url,
+                proxyIconURL: embed.author.proxy_icon_url
+            },
+            color: embed.color,
+            description: embed.description,
+            fields: embed.fields?.map(field => ({
+                inline: field.inline,
+                name: field.name,
+                value: field.value
+            })),
+            flags: embed.flags,
+            footer: embed.footer === undefined ? undefined : {
+                flags: embed.footer.flags,
+                iconURL: embed.footer.icon_url,
+                proxyIconURL: embed.footer.proxy_icon_url,
+                text: embed.footer.text
+            },
+            timestamp: embed.timestamp,
+            title: embed.title,
+            image: embed.image === undefined ? undefined : {
+                flags: embed.image.flags,
+                height: embed.image.height,
+                proxyURL: embed.image.proxy_url,
+                url: embed.image.url,
+                width: embed.image.width
+            },
+            provider: embed.provider === undefined ? undefined : {
+                name: embed.provider.name,
+                url: embed.provider.url
+            },
+            thumbnail: embed.thumbnail === undefined ? undefined : {
+                url: embed.thumbnail.url,
+                height: embed.thumbnail.height,
+                proxyURL: embed.thumbnail.proxy_url,
+                width: embed.thumbnail.width
+            },
+            url: embed.url,
+            type: embed.type,
+            video: embed.video === undefined ? undefined : {
+                height: embed.video.height,
+                proxyURL: embed.video.proxy_url,
+                url: embed.video.url,
+                width: embed.video.width
+            }
+        }));
+    }
+    embedsToRaw(embeds) {
+        return embeds.map(embed => ({
+            author: embed.author === undefined ? undefined : {
+                name: embed.author.name,
+                icon_url: embed.author.iconURL,
+                url: embed.author.url
+            },
+            color: embed.color,
+            description: embed.description,
+            fields: embed.fields?.map(field => ({
+                inline: field.inline,
+                name: field.name,
+                value: field.value
+            })),
+            footer: embed.footer === undefined ? undefined : {
+                text: embed.footer.text,
+                icon_url: embed.footer.iconURL
+            },
+            timestamp: embed.timestamp,
+            title: embed.title,
+            image: embed.image === undefined ? undefined : { url: embed.image.url },
+            thumbnail: embed.thumbnail === undefined ? undefined : { url: embed.thumbnail.url },
+            url: embed.url
+        }));
+    }
+    formatAllowedMentions(allowed) {
+        const result = { parse: [] };
+        if (!allowed) {
+            return this.formatAllowedMentions(this._client.options.allowedMentions);
+        }
+        if (allowed.everyone === true) {
+            result.parse.push("everyone");
+        }
+        if (allowed.roles === true) {
+            result.parse.push("roles");
+        }
+        else if (Array.isArray(allowed.roles)) {
+            result.roles = allowed.roles;
+        }
+        if (allowed.users === true) {
+            result.parse.push("users");
+        }
+        else if (Array.isArray(allowed.users)) {
+            result.users = allowed.users;
+        }
+        if (allowed.repliedUser === true) {
+            result.replied_user = true;
+        }
+        return result;
+    }
+    formatImage(url, format, size) {
+        if (!format || !Constants_1.ImageFormats.includes(format.toLowerCase())) {
+            format = url.includes("/a_") ? "gif" : this._client.options.defaultImageFormat;
+        }
+        if (!size || !Constants_1.MEDIA_PROXY_SIZES.includes(size)) {
+            size = this._client.options.defaultImageSize;
+        }
+        return `${Routes_1.CDN_URL}${url}.${format}?size=${size}`;
+    }
+    getMagic(file, len = 4) {
+        return [...new Uint8Array(file.subarray(0, len))].map(b => b.toString(16).padStart(2, "0")).join("").toUpperCase();
+    }
+    modalSubmitComponentToParsed(component) {
+        switch (component.type) {
+            case Constants_1.ComponentTypes.CHECKBOX:
+            case Constants_1.ComponentTypes.RADIO_GROUP:
+            case Constants_1.ComponentTypes.TEXT_INPUT: {
+                return {
+                    customID: component.custom_id,
+                    type: component.type,
+                    value: component.value
+                };
+            }
+            case Constants_1.ComponentTypes.STRING_SELECT:
+            case Constants_1.ComponentTypes.USER_SELECT:
+            case Constants_1.ComponentTypes.ROLE_SELECT:
+            case Constants_1.ComponentTypes.MENTIONABLE_SELECT:
+            case Constants_1.ComponentTypes.CHANNEL_SELECT:
+            case Constants_1.ComponentTypes.CHECKBOX_GROUP:
+            case Constants_1.ComponentTypes.FILE_UPLOAD: {
+                return {
+                    customID: component.custom_id,
+                    type: component.type,
+                    values: component.values
+                };
+            }
+            default: {
+                return component;
+            }
+        }
+    }
+    modalSubmitComponentsToParsed(components) {
+        return components.map(row => {
+            if (row.type === Constants_1.ComponentTypes.ACTION_ROW) {
+                return {
+                    type: row.type,
+                    components: row.components ? row.components.map(component => this.modalSubmitComponentToParsed(component)) : undefined
+                };
+            }
+            else {
+                return {
+                    type: row.type,
+                    component: row.component ? this.modalSubmitComponentToParsed(row.component) : undefined
+                };
+            }
+        });
+    }
+    optionToParsed(option) {
+        return {
+            autocomplete: option.autocomplete,
+            channelTypes: option.channel_types,
+            choices: option.choices,
+            description: option.description,
+            descriptionLocalizations: option.description_localizations,
+            descriptionLocalized: option.description_localized,
+            max_length: option.max_length,
+            max_value: option.max_value,
+            min_length: option.min_length,
+            min_value: option.min_value,
+            name: option.name,
+            nameLocalizations: option.name_localizations,
+            nameLocalized: option.name_localized,
+            options: option.options?.map(o => this.optionToParsed(o)),
+            required: option.required,
+            type: option.type
+        };
+    }
+    optionToRaw(option) {
+        const opt = option;
+        return {
+            autocomplete: opt.autocomplete,
+            channel_types: opt.channelTypes,
+            choices: opt.choices?.map(choice => ({
+                name: choice.name,
+                name_localizations: choice.nameLocalizations,
+                value: choice.value
+            })),
+            description: opt.description,
+            description_localizations: opt.descriptionLocalizations,
+            max_length: opt.maxLength,
+            max_value: opt.maxValue,
+            min_length: opt.minLength,
+            min_value: opt.minValue,
+            name: opt.name,
+            name_localizations: opt.nameLocalizations,
+            options: opt.options?.map(o => this.optionToRaw(o)),
+            required: opt.required,
+            type: opt.type
+        };
+    }
+    /** @internal */
+    replacePollAnswer(poll, answerID, count, users) {
+        let answerCount = poll.results.answerCounts.find(a => a.id === answerID);
+        if (!answerCount) {
+            answerCount = {
+                count,
+                id: answerID,
+                users: [],
+                meVoted: false
+            };
+        }
+        answerCount.count = count;
+        if (users) {
+            answerCount.users = users;
+            answerCount.meVoted = (this._client["_user"] && users.includes(this._client["_user"]?.id)) ?? false;
+        }
+    }
+    updateChannel(channelData) {
+        guild: if (channelData.guild_id) {
+            const guild = this._client.guilds.get(channelData.guild_id);
+            if (guild) {
+                if (Constants_1.ThreadChannelTypes.includes(channelData.type)) {
+                    if (!channelData.parent_id) {
+                        break guild;
+                    }
+                    return guild.threads.update(channelData);
+                }
+                else {
+                    return guild.channels.update(channelData);
+                }
+            }
+        }
+        switch (channelData.type) {
+            case Constants_1.ChannelTypes.DM: return this._client.privateChannels.update(channelData);
+            case Constants_1.ChannelTypes.GROUP_DM: return this._client.groupChannels.update(channelData);
+            default: return Channel_1.default.from(channelData, this._client);
+        }
+    }
+    /** @internal */
+    updateEntitlement(data) {
+        if (this._client["_application"] === undefined) {
+            return "subscription_id" in data && data.subscription_id ?
+                new Entitlement_1.default(data, this._client) :
+                new TestEntitlement_1.default(data, this._client);
+        }
+        else {
+            return this._client.application.entitlements.update(data);
+        }
+    }
+    /** @internal */
+    updateMember(guildID, memberID, member) {
+        const guild = this._client.guilds.get(guildID);
+        if (guild && this._client["_user"] && this._client.user.id === memberID) {
+            if (guild["_clientMember"]) {
+                guild["_clientMember"]["update"](member);
+            }
+            else {
+                guild["_clientMember"] = guild.members.update({ ...member, id: memberID }, guildID);
+            }
+            return guild["_clientMember"];
+        }
+        return guild ? guild.members.update({ ...member, id: memberID }, guildID) : new Member_1.default({ ...member, id: memberID }, this._client, guildID);
+    }
+    /** @internal */
+    updateMessage(data) {
+        const channel = this._client.getChannel(data.channel_id);
+        if (channel && "messages" in channel) {
+            return channel.messages.update(data);
+        }
+        return new Message_1.default(data, this._client);
+    }
+    /** @internal */
+    updatePollAnswer(poll, answerID, count, user) {
+        let answerCount = poll.results.answerCounts.find(a => a.id === answerID);
+        if (!answerCount) {
+            if (count === -1) {
+                return;
+            }
+            answerCount = {
+                count,
+                id: answerID,
+                users: user ? [user] : [],
+                meVoted: user === this._client["_user"]?.id
+            };
+            poll.results.answerCounts.push(answerCount);
+            return;
+        }
+        answerCount.count += count;
+        if (user) {
+            if (count === 1 && !answerCount.users.includes(user)) {
+                answerCount.users.push(user);
+                answerCount.meVoted = user === this._client["_user"]?.id;
+            }
+            else if (count === -1 && answerCount.users.includes(user)) {
+                answerCount.users.splice(answerCount.users.indexOf(user), 1);
+                if (user === this._client["_user"]?.id) {
+                    answerCount.meVoted = false;
+                }
+            }
+        }
+    }
+    /** @internal */
+    updateThread(threadData) {
+        const guild = this._client.guilds.get(threadData.guild_id);
+        if (guild) {
+            return guild.threads.update(threadData);
+        }
+        return Channel_1.default.from(threadData, this._client);
+    }
+}
+exports.default = Util;