FoundationEntities.cpp

Go to the documentation of this file.

/*
    DiscordCoreAPI, A bot library for Discord, written in C++, and featuring explicit multithreading through the usage of custom, asynchronous C++ CoRoutines.
 
    Copyright 2021, 2022 Chris M. (RealTimeChris)
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.
 
    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
    Lesser General Public License for more details.
 
    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
    USA
*/
/// FoundationEntities.cpp - Source file for the foundation entities.
/// Oct 1, 2021
/// https://discordcoreapi.com
/// \file FoundationEntities.cpp
 
#include <discordcoreapi/FoundationEntities.hpp>
#include <discordcoreapi/GuildEntities.hpp>
#include <discordcoreapi/GuildMemberEntities.hpp>
#include <discordcoreapi/InteractionEntities.hpp>
#include <discordcoreapi/GuildScheduledEventEntities.hpp>
#include <discordcoreapi/DataParsingFunctions.hpp>
#include <discordcoreapi/RoleEntities.hpp>
#include <discordcoreapi/UserEntities.hpp>
#include <discordcoreapi/ChannelEntities.hpp>
#include <discordcoreapi/CoRoutine.hpp>
#include <discordcoreapi/InputEvents.hpp>
#include <discordcoreapi/DiscordCoreClient.hpp>
#include <discordcoreapi/DataParsingFunctions.hpp>
 
namespace DiscordCoreInternal {
 
    WebSocketResumeData::operator Jsonifier::Serializer() {
        Jsonifier::Serializer data{};
        data["op"] = 6;
        data["d"]["seq"] = this->lastNumberReceived;
        data["d"]["session_id"] = this->sessionId;
        data["d"]["token"] = this->botToken;
        return data;
    }
 
    WebSocketIdentifyData::operator Jsonifier::Serializer() {
        Jsonifier::Serializer serializer{};
        serializer["d"]["intents"] = this->intents;
        serializer["d"]["large_threshold"] = 250;
        for (auto& value: this->presence.activities) {
            Jsonifier::Serializer serializer01{};
            if (value.url != "") {
                serializer01["url"] = value.url;
            }
            serializer01["name"] = value.name;
            serializer01["type"] = value.type;
            serializer["d"]["presence"]["activities"].emplaceBack(serializer01);
        }
        serializer["d"]["presence"]["afk"] = this->presence.afk;
        if (this->presence.since != 0) {
            serializer["d"]["presence"]["since"] = this->presence.since;
        }
        switch (this->presence.status) {
            case DiscordCoreAPI::UpdatePresenceStatusTypes::online: {
                serializer["d"]["presence"]["status"] = "online";
                break;
            }
            case DiscordCoreAPI::UpdatePresenceStatusTypes::dnd: {
                serializer["d"]["presence"]["status"] = "dnd";
                break;
            }
            case DiscordCoreAPI::UpdatePresenceStatusTypes::invisible: {
                serializer["d"]["presence"]["status"] = "invisible";
                break;
            }
            case DiscordCoreAPI::UpdatePresenceStatusTypes::offline: {
                serializer["d"]["presence"]["status"] = "offline";
                break;
            }
            case DiscordCoreAPI::UpdatePresenceStatusTypes::idle: {
                serializer["d"]["presence"]["status"] = "idle";
                break;
            }
        }
        serializer["d"]["properties"]["browser"] = "DiscordCoreAPI";
        serializer["d"]["properties"]["device"] = "DiscordCoreAPI";
#ifdef _WIN32
        serializer["d"]["properties"]["os"] = "Windows";
#elif __linux__
        serializer["d"]["properties"]["os"] = "Linux";
#endif
        serializer["d"]["shard"].emplaceBack(this->currentShard);
        serializer["d"]["shard"].emplaceBack(this->numberOfShards);
        serializer["d"]["token"] = this->botToken;
        serializer["op"] = 2;
        return serializer;
    }
 
    VoiceSocketProtocolPayloadData::operator Jsonifier::Serializer() {
        Jsonifier::Serializer data{};
        data["op"] = 1;
        data["d"]["protocol"] = "udp";
        data["d"]["data"]["port"] = this->voicePort;
        data["d"]["data"]["mode"] = this->voiceEncryptionMode;
        std::string externalIpReal{};
        for (auto& value: this->externalIp) {
            externalIpReal.push_back(value);
        }
        data["d"]["data"]["address"] = externalIpReal;
        return data;
    }
 
    VoiceIdentifyData::operator Jsonifier::Serializer() {
        Jsonifier::Serializer data{};
        data["op"] = 0;
        data["d"]["session_id"] = this->connectionData.sessionId;
        data["d"]["token"] = this->connectionData.token;
        data["d"]["server_id"] = this->connectInitData.guildId;
        data["d"]["user_id"] = this->connectInitData.userId;
        return data;
    }
 
    SendSpeakingData::operator Jsonifier::Serializer() {
        Jsonifier::Serializer data{};
        data["op"] = 5;
        data["d"]["speaking"] = static_cast<int32_t>(this->type);
        data["d"]["delay"] = this->delay;
        data["d"]["ssrc"] = this->ssrc;
        return data;
    }
 
    HttpsWorkloadData& HttpsWorkloadData::operator=(HttpsWorkloadData&& other) noexcept {
        if (this != &other) {
            this->headersToInsert = std::move(other.headersToInsert);
            this->thisWorkerId.store(this->thisWorkerId.load());
            this->relativePath = std::move(other.relativePath);
            this->callStack = std::move(other.callStack);
            this->workloadClass = other.workloadClass;
            this->baseUrl = std::move(other.baseUrl);
            this->content = std::move(other.content);
            this->workloadType = other.workloadType;
            this->payloadType = other.payloadType;
        }
        return *this;
    }
 
    HttpsWorkloadData& HttpsWorkloadData::operator=(HttpsWorkloadType type) noexcept {
        if (!HttpsWorkloadData::workloadIdsExternal.contains(type)) {
            std::unique_ptr<std::atomic_int64_t> integer{ std::make_unique<std::atomic_int64_t>() };
            std::unique_ptr<std::atomic_int64_t> integer02{ std::make_unique<std::atomic_int64_t>() };
            HttpsWorkloadData::workloadIdsExternal[type] = std::move(integer);
            HttpsWorkloadData::workloadIdsInternal[type] = std::move(integer02);
        }
        this->thisWorkerId.store(HttpsWorkloadData::incrementAndGetWorkloadId(type));
        this->workloadType = type;
        return *this;
    }
 
    HttpsWorkloadData::HttpsWorkloadData(HttpsWorkloadType type) noexcept {
        *this = type;
    }
 
    int64_t HttpsWorkloadData::incrementAndGetWorkloadId(HttpsWorkloadType workloadType) noexcept {
        int64_t value{ HttpsWorkloadData::workloadIdsExternal[workloadType]->load() };
        HttpsWorkloadData::workloadIdsExternal[workloadType]->store(value + 1);
        return value;
    }
 
    std::unordered_map<HttpsWorkloadType, std::unique_ptr<std::atomic_int64_t>> HttpsWorkloadData::workloadIdsExternal{};
    std::unordered_map<HttpsWorkloadType, std::unique_ptr<std::atomic_int64_t>> HttpsWorkloadData::workloadIdsInternal{};
 
    HelloData::HelloData(Jsonifier::Value jsonData) {
        this->heartbeatInterval = DiscordCoreAPI::getUint64(jsonData, "heartbeat_interval");
    }
 
    WebSocketMessage::WebSocketMessage(Jsonifier::Value jsonData) {
        this->op = DiscordCoreAPI::getInt32(jsonData, "op");
 
        this->s = DiscordCoreAPI::getInt32(jsonData, "s");
 
        this->t = DiscordCoreAPI::getString(jsonData, "t");
    }
 
    InvalidSessionData::InvalidSessionData(Jsonifier::Value jsonData) {
        this->d = DiscordCoreAPI::getBool(jsonData, "d");
    }
 
    ReadyData::ReadyData(Jsonifier::Value jsonData) {
        this->resumeGatewayUrl = DiscordCoreAPI::getString(jsonData, "resume_gateway_url");
        this->resumeGatewayUrl = this->resumeGatewayUrl.substr(this->resumeGatewayUrl.find("wss://") + std::string{ "wss://" }.size());
        this->resumeGatewayUrl = this->resumeGatewayUrl.substr(0, this->resumeGatewayUrl.find("/"));
 
        this->sessionId = DiscordCoreAPI::getString(jsonData, "session_id");
 
        this->v = DiscordCoreAPI::getUint32(jsonData, "v");
 
        Jsonifier::Value user{};
        if (jsonData["user"].get(user) == Jsonifier::ErrorCode::Success) {
            this->user = DiscordCoreAPI::UserData{ user };
        }
    }
}
 
namespace DiscordCoreAPI {
 
    UpdatePresenceData::operator Serializer() {
        Serializer data{};
        data["op"] = 3;
        for (auto& value: this->activities) {
            Serializer dataNew{};
            if (value.url != "") {
                dataNew["url"] = std::string{ value.url };
            }
            dataNew["name"] = std::string{ value.name };
            dataNew["type"] = value.type;
            data["d"]["activities"].emplaceBack(dataNew);
        }
        switch (this->status) {
            case UpdatePresenceStatusTypes::online: {
                data["status"] = "online";
                break;
            }
            case UpdatePresenceStatusTypes::dnd: {
                data["status"] = "dnd";
                break;
            }
            case UpdatePresenceStatusTypes::invisible: {
                data["status"] = "invisible";
                break;
            }
            case UpdatePresenceStatusTypes::offline: {
                data["status"] = "offline";
                break;
            }
            case UpdatePresenceStatusTypes::idle: {
                data["status"] = "idle";
                break;
            }
        }
        if (this->since != 0) {
            data["since"] = this->since;
        }
        data["afk"] = this->afk;
        return data;
    }
 
    std::string DiscordEntity::getCreatedAtTimestamp(TimeFormat timeFormat) {
        TimeStamp timeStamp{ (this->id.operator size_t() >> 22) + 1420070400000, timeFormat };
        return timeStamp.operator std::string();
    }
 
    RoleTagsData::RoleTagsData(Value jsonData) {
        this->botId = getString(jsonData, "bot_id");
 
        this->integrationId = getString(jsonData, "integration_id");
    }
 
    UserData::UserData(Value jsonData) {
        this->id = getId(jsonData, "id");
        if (this->id == 0) {
            return;
        }
 
        int32_t newFlags{};
        newFlags = setBool(newFlags, UserFlags::MFAEnabled, getBool(jsonData, "mfa_enabled"));
 
        newFlags = setBool(newFlags, UserFlags::Verified, getBool(jsonData, "verified"));
 
        newFlags = setBool(newFlags, UserFlags::System, getBool(jsonData, "system"));
 
        newFlags = setBool(newFlags, UserFlags::Bot, getBool(jsonData, "bot"));
 
        newFlags += getUint32(jsonData, "public_flags");
 
        newFlags = setBool(newFlags, this->flags, true);
 
        this->flags = static_cast<UserFlags>(newFlags);
 
        this->userName = getString(jsonData, "username");
 
        this->avatar = getString(jsonData, "avatar");
 
        this->discriminator = getString(jsonData, "discriminator");
    }
 
    std::string UserData::getAvatarUrl() {
        std::string stringNew{ "https://cdn.discordapp.com/" };
        stringNew += "avatars/" + this->id + "/" + this->avatar.getIconHash();
        return stringNew;
    }
 
    AttachmentData ::AttachmentData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->filename = getString(jsonData, "filename");
 
        this->contentType = getString(jsonData, "content_type");
 
        this->ephemeral = getBool(jsonData, "ephemeral");
 
        this->description = getString(jsonData, "description");
 
        this->size = getUint32(jsonData, "size");
 
        this->url = getString(jsonData, "url");
 
        this->proxyUrl = getString(jsonData, "proxy_url");
 
        this->width = getUint32(jsonData, "width");
 
        this->height = getUint32(jsonData, "height");
    }
 
    EmbedFooterData::EmbedFooterData(Value jsonData) {
        this->text = getString(jsonData, "text");
 
        this->iconUrl = getString(jsonData, "icon_url");
 
        this->proxyIconUrl = getString(jsonData, "proxy_icon_url");
    }
 
    EmbedImageData::EmbedImageData(Value jsonData) {
        this->url = getString(jsonData, "url");
 
        this->proxyUrl = getString(jsonData, "proxy_url");
 
        this->width = getUint32(jsonData, "width");
 
        this->height = getUint32(jsonData, "height");
    }
 
    EmbedThumbnailData::EmbedThumbnailData(Value jsonData) {
        this->url = getString(jsonData, "url");
 
        this->proxyUrl = getString(jsonData, "proxy_url");
 
        this->width = getUint32(jsonData, "width");
 
        this->height = getUint32(jsonData, "height");
    }
 
    EmbedVideoData::EmbedVideoData(Value jsonData) {
        this->url = getString(jsonData, "url");
 
        this->proxyUrl = getString(jsonData, "proxy_url");
 
        this->width = getUint32(jsonData, "width");
 
        this->height = getUint32(jsonData, "height");
    }
 
    EmbedProviderData::EmbedProviderData(Value jsonData) {
        this->url = getString(jsonData, "url");
 
        this->name = getString(jsonData, "name");
    }
 
    EmbedAuthorData::EmbedAuthorData(Value jsonData) {
        this->url = getString(jsonData, "url");
 
        this->proxyIconUrl = getString(jsonData, "proxy_icon_url");
 
        this->name = getString(jsonData, "name");
 
        this->iconUrl = getString(jsonData, "icon_url");
    }
 
    EmbedFieldData::EmbedFieldData(Value jsonData) {
        this->Inline = getBool(jsonData, "inline");
 
        this->name = getString(jsonData, "name");
 
        this->value = getString(jsonData, "value");
    }
 
    EmbedData::EmbedData(Value jsonData) {
        this->title = getString(jsonData, "title");
 
        this->type = getString(jsonData, "type");
 
        this->description = getString(jsonData, "description");
 
        this->url = getString(jsonData, "url");
 
        this->timeStamp = getString(jsonData, "timestamp");
 
        this->hexColorValue = getUint32(jsonData, "color");
 
        Value object{};
        if (!getObject(object, "footer", jsonData)) {
            EmbedFooterData data{ object };
            this->footer = std::move(data);
        }
 
        if (!getObject(object, "image", jsonData)) {
            EmbedImageData data{ object };
            this->image = std::move(data);
        }
 
        if (!getObject(object, "provider", jsonData)) {
            EmbedProviderData data{ object };
            this->provider = std::move(data);
        }
 
        if (!getObject(object, "thumbnail", jsonData)) {
            EmbedThumbnailData data{ object };
            this->thumbnail = std::move(data);
        }
 
        if (!getObject(object, "video", jsonData)) {
            EmbedVideoData data{ object };
            this->video = std::move(data);
        }
 
        if (!getObject(object, "author", jsonData)) {
            EmbedAuthorData data{ object };
            this->author = std::move(data);
        }
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "fields", jsonData)) {
            this->fields.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                EmbedFieldData newData{ value.value() };
                this->fields.emplace_back(std::move(newData));
            }
        }
    }
 
    MessageReferenceData::MessageReferenceData(Value jsonData) {
        this->messageId = getId(jsonData, "message_id");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->failIfNotExists = getBool(jsonData, "fail_if_not_exists");
    }
 
    ThreadMetadataData::ThreadMetadataData(Value jsonData) {
        this->archived = getBool(jsonData, "archived");
 
        this->invitable = getBool(jsonData, "invitable");
 
        this->autoArchiveDuration = getUint32(jsonData, "auto_archive_duration");
 
        this->archiveTimestamp = getString(jsonData, "archive_timestamp");
 
        this->locked = getBool(jsonData, "locked");
    }
 
    ThreadMemberData::ThreadMemberData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->userId = getId(jsonData, "user_id");
 
        this->joinTimestamp = getString(jsonData, "join_timestamp");
 
        this->flags = getUint32(jsonData, "flags");
    }
 
    ThreadMemberDataVector::ThreadMemberDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    ThreadMemberData newData{ value.value() };
                    this->threadMembers.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    VoiceStateDataLight::VoiceStateDataLight(Value jsonData) {
        this->channelId = getId(jsonData, "channel_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->userId = getId(jsonData, "user_id");
    }
 
    VoiceStateData::VoiceStateData(Value jsonData) {
        this->requestToSpeakTimestamp = getString(jsonData, "request_to_speak_timestamp");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->selfStream = getBool(jsonData, "self_stream");
 
        this->userId = getId(jsonData, "user_id");
 
        this->selfVideo = getBool(jsonData, "self_video");
 
        this->sessionId = getString(jsonData, "session_id");
 
        this->selfDeaf = getBool(jsonData, "self_deaf");
 
        this->selfMute = getBool(jsonData, "self_mute");
 
        this->suppress = getBool(jsonData, "suppress");
 
        this->deaf = getBool(jsonData, "deaf");
 
        this->mute = getBool(jsonData, "mute");
    }
 
    RoleData::RoleData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->name = getString(jsonData, "name");
 
        std::stringstream stream{};
        stream << getString(jsonData, "unicode_emoji");
        for (auto& value: stream.str()) {
            this->unicodeEmoji.emplace_back(value);
        }
        if (this->unicodeEmoji.size() > 3) {
            this->unicodeEmoji = static_cast<std::string>(this->unicodeEmoji).substr(1, this->unicodeEmoji.size() - 3);
        }
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->color = getUint32(jsonData, "color");
 
        uint8_t newFlags{};
        newFlags = setBool(newFlags, RoleFlags::Hoist, getBool(jsonData, "hoist"));
 
        newFlags = setBool(newFlags, RoleFlags::Managed, getBool(jsonData, "managed"));
 
        newFlags = setBool(newFlags, RoleFlags::Mentionable, getBool(jsonData, "mentionable"));
 
        this->flags = static_cast<RoleFlags>(newFlags);
 
        this->position = getUint32(jsonData, "position");
 
        this->permissions = getString(jsonData, "permissions");
    }
 
    EmojiData::EmojiData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->name = getString(jsonData, "name");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "roles", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                RoleData newData{ value.value() };
                this->roles.emplace_back(std::move(newData));
            }
        }
 
        Value object{};
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
 
        this->requireColons = getBool(jsonData, "require_colons");
 
        this->managed = getBool(jsonData, "managed");
 
        this->animated = getBool(jsonData, "animated");
 
        this->available = getBool(jsonData, "available");
    }
 
    PresenceUpdateData::PresenceUpdateData(Value jsonData) {
        this->guildId = getId(jsonData, "guild_id");
 
        auto stringNew = getString(jsonData, "status");
 
        if (stringNew == "online") {
            uint8_t newFlags = setBool(uint8_t{}, PresenceUpdateFlags::Status_Online, true);
            this->theStatus = static_cast<PresenceUpdateFlags>(newFlags);
        } else if (stringNew == "idle") {
            uint8_t newFlags = setBool(uint8_t{}, PresenceUpdateFlags::Status_Idle, true);
            this->theStatus = static_cast<PresenceUpdateFlags>(newFlags);
        } else if (stringNew == "dnd") {
            uint8_t newFlags = setBool(uint8_t{}, PresenceUpdateFlags::Status_Dnd, true);
            this->theStatus = static_cast<PresenceUpdateFlags>(newFlags);
        }
 
        parseObject(jsonData, this->theStatus);
    }
 
    GuildMemberData& GuildMemberData::operator=(GuildMemberData&& other) noexcept {
        if (this != &other) {
            this->permissions = std::move(other.permissions);
            this->joinedAt = std::move(other.joinedAt);
            this->avatar = std::move(other.avatar);
            this->roles = std::move(other.roles);
            this->flags = std::move(other.flags);
            this->nick = std::move(other.nick);
            this->guildId = other.guildId;
            this->id = other.id;
        }
        return *this;
    }
 
    GuildMemberData& GuildMemberData::operator=(Value jsonData) {
        uint8_t newFlags{};
        newFlags = setBool(newFlags, GuildMemberFlags::Pending, getBool(jsonData, "pending"));
 
        newFlags = setBool(newFlags, GuildMemberFlags::Mute, getBool(jsonData, "mute"));
 
        newFlags = setBool(newFlags, GuildMemberFlags::Deaf, getBool(jsonData, "deaf"));
 
        this->flags = static_cast<GuildMemberFlags>(newFlags);
 
        this->joinedAt = getString(jsonData, "joined_at");
 
        this->guildId = getId(jsonData, "guild_id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "roles", jsonData)) {
            this->roles.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                this->roles.emplace_back(getId(value.value()));
            }
        }
 
        this->permissions = getString(jsonData, "permissions");
 
        Value object{};
        if (!getObject(object, "user", jsonData)) {
            UserData user{ object };
            this->id = user.id;
            Users::insertUser(std::move(user));
        }
 
        this->avatar = getString(jsonData, "avatar");
 
        newFlags += getUint8(jsonData, "flags");
 
        this->flags = static_cast<GuildMemberFlags>(newFlags);
 
        this->nick = getString(jsonData, "nick");
        return *this;
    }
 
    GuildMemberData::GuildMemberData(Value jsonData) {
        *this = jsonData;
    }
 
    VoiceStateDataLight GuildMemberData::getVoiceStateData() {
        VoiceStateDataLight dataToGet{};
        dataToGet.guildId = this->guildId;
        dataToGet.userId = this->id;
        if (GuildMembers::getVsCache().contains(dataToGet)) {
            return GuildMembers::getVsCache()[dataToGet];
        } else {
            return dataToGet;
        }
    }
 
    std::string GuildMemberData::getAvatarUrl() {
        if (this->avatar.getIconHash() != "") {
            std::string stringNew{ "https://cdn.discordapp.com/" };
            stringNew += "guilds/" + this->guildId + "/users/" + this->id + "/avatars/" + this->avatar.getIconHash();
            return stringNew;
        } else {
            return this->getUserData().getAvatarUrl();
        }
    }
 
    UserData GuildMemberData::getUserData() {
        if (this->id.operator size_t() != 0) {
            return Users::getCachedUser({ .userId = this->id });
        } else {
            return {};
        }
    }
 
    OverWriteData::OverWriteData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->allow = getUint64(jsonData, "allow");
 
        this->deny = getUint64(jsonData, "deny");
 
        this->type = static_cast<PermissionOverwritesType>(getUint8(jsonData, "type"));
    }
 
    DefaultReactionData::DefaultReactionData(Value jsonData) {
        this->emojiId = getId(jsonData, "emoji_id");
 
        this->emojiName = getString(jsonData, "emoji_name");
    }
 
    ForumTagData::ForumTagData(Value jsonData) {
        this->emojiId = getId(jsonData, "emoji_id");
 
        this->emojiName = getString(jsonData, "emoji_name");
 
        this->id = getId(jsonData, "id");
 
        this->moderated = getBool(jsonData, "moderated");
 
        this->name = getString(jsonData, "name");
    }
 
    ChannelData::ChannelData(Value jsonData) {
        uint8_t newFlags{};
        newFlags = setBool(newFlags, ChannelFlags::NSFW, getBool(jsonData, "nsfw"));
 
        this->type = static_cast<ChannelType>(getUint8(jsonData, "type"));
 
        this->defaultSortOrder = static_cast<SortOrderTypes>(getUint8(jsonData, "default_sort_order"));
 
        this->memberCount = getUint32(jsonData, "member_count");
 
        this->ownerId = getId(jsonData, "owner_id");
 
        this->id = getId(jsonData, "id");
 
        newFlags += getUint8(jsonData, "flags");
 
        this->flags = static_cast<ChannelFlags>(newFlags);
 
        this->parentId = getId(jsonData, "parent_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->position = getUint32(jsonData, "position");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "permission_overwrites", jsonData)) {
            this->permissionOverwrites.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                OverWriteData dataNew{ value.value() };
                this->permissionOverwrites.emplace_back(std::move(dataNew));
            }
        }
 
        this->name = getString(jsonData, "name");
    }
 
    ActiveThreadsData::ActiveThreadsData(Value jsonData) {
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "threads", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ChannelData newData{ value.value() };
                this->threads.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "members", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ThreadMemberData newData{ value.value() };
                this->members.emplace_back(std::move(newData));
            }
        }
 
        this->hasMore = getBool(jsonData, "has_more");
    }
 
    ArchivedThreadsData::ArchivedThreadsData(Value jsonData) {
        Jsonifier::Array arrayValue{};
 
        if (!getArray(arrayValue, "threads", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ChannelData newData{ value.value() };
                this->threads.emplace_back(std::move(newData));
            }
        }
 
        ;
        if (!getArray(arrayValue, "members", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ThreadMemberData newData{ value.value() };
                this->members.emplace_back(std::move(newData));
            }
        }
 
        this->hasMore = getBool(jsonData, "has_more");
    }
 
    TriggerMetaData::TriggerMetaData(Value jsonData) {
        Jsonifier::Array arrayValue{};
 
        if (!getArray(arrayValue, "keyword_filter", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->keywordFilter.emplace_back(value.getString().value().data());
            }
        }
 
        if (!getArray(arrayValue, "presets", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->presets.emplace_back(static_cast<KeywordPresetType>(value.getUint64().value()));
            }
        }
 
        if (!getArray(arrayValue, "allow_list", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->allowList.emplace_back(value.getString().value());
            }
        }
 
        this->mentionTotalLimit = getUint32(jsonData, "mention_total_limit");
    }
 
    ActionMetaData::ActionMetaData(Value jsonData) {
        this->channelId = getId(jsonData, "channel_id");
 
        this->durationSeconds = getUint64(jsonData, "duration_seconds");
    }
 
    ActionData::ActionData(Value jsonData) {
        Value object{};
        if (!getObject(object, "metadata", jsonData)) {
            this->metadata = ActionMetaData{ object };
        }
 
        this->type = static_cast<ActionType>(getUint64(jsonData, "type"));
    }
 
    AutoModerationRuleData::AutoModerationRuleData(Value jsonData) {
        this->name = getString(jsonData, "name");
 
        this->id = getId(jsonData, "id");
 
        this->enabled = getBool(jsonData, "enabled");
 
        this->triggerType = static_cast<TriggerType>(getUint8(jsonData, "trigger_type"));
 
        this->eventType = static_cast<EventType>(getUint8(jsonData, "event_type"));
 
        this->creatorId = getId(jsonData, "creator_id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "actions", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ActionData newData{ value.value() };
                this->actions.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "exempt_roles", jsonData)) {
            this->exemptRoles.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                this->exemptRoles.emplace_back(strtoull(std::string{ value.getString().takeValue() }));
            }
        }
 
        if (!getArray(arrayValue, "exempt_channels", jsonData)) {
            this->exemptChannels.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                this->exemptChannels.emplace_back(strtoull(std::string{ value.getString().takeValue() }));
            }
        }
 
        Value object{};
        if (!getObject(object, "trigger_metadata", jsonData)) {
            this->triggerMetaData = TriggerMetaData{ object };
        }
 
        this->guildId = getId(jsonData, "guild_id");
    }
 
    ApplicationCommandPermissionData::ApplicationCommandPermissionData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->permission = getBool(jsonData, "permission");
 
        this->type = static_cast<ApplicationCommandPermissionType>(getUint8(jsonData, "type"));
    }
 
    GuildApplicationCommandPermissionsData::GuildApplicationCommandPermissionsData(Value jsonData) {
        this->guildId = getId(jsonData, "guild_id");
 
        this->applicationId = getId(jsonData, "application_id");
 
        this->id = getId(jsonData, "id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "permissions", jsonData)) {
            this->permissions.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ApplicationCommandPermissionData newData{ value.value() };
                this->permissions.emplace_back(std::move(newData));
            }
        }
    }
 
    GuildApplicationCommandPermissionsDataVector::GuildApplicationCommandPermissionsDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    GuildApplicationCommandPermissionsData newData{ value.value() };
                    this->guildApplicationCommandPermissionss.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    EmojiDataVector::EmojiDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    EmojiData newData{ value.value() };
                    this->theEmojis.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    ReactionData::ReactionData(Value jsonData) {
        this->count = getUint32(jsonData, "count");
 
        this->me = getBool(jsonData, "me");
 
        Value object{};
        if (!getObject(object, "emoji", jsonData)) {
            this->emoji = EmojiData{ object };
        }
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->userId = getId(jsonData, "user_id");
 
        this->messageId = getId(jsonData, "message_id");
 
        if (!getObject(object, "member", jsonData)) {
            this->member = GuildMemberData{ object };
        }
    }
 
    VoiceRegionData::VoiceRegionData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->custom = getBool(jsonData, "custom");
 
        this->deprecated = getBool(jsonData, "deprecated");
 
        this->optimal = getBool(jsonData, "optimal");
 
        this->name = getString(jsonData, "name");
    }
 
    VoiceRegionDataVector::VoiceRegionDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    VoiceRegionData newData{ value.value() };
                    this->voiceRegions.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    MessageActivityData::MessageActivityData(Value jsonData) {
        this->type = static_cast<MessageActivityType>(getUint8(jsonData, "type"));
 
        this->partyId = getString(jsonData, "party_id");
    }
 
    BanData::BanData(Value jsonData) {
        Value object{};
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
 
        this->reason = getString(jsonData, "reason");
    }
 
    BanDataVector::BanDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    BanData newData{ value.value() };
                    this->bans.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    TeamMembersObjectData::TeamMembersObjectData(Value jsonData) {
        this->membershipState = getUint32(jsonData, "membership_state");
 
        this->teamId = getId(jsonData, "team_id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "permissions", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->permissions.emplace_back(Permissions{ value.getString().value().data() });
            }
        }
 
        Value object{};
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
    }
 
    TeamObjectData::TeamObjectData(Value jsonData) {
        this->icon = getString(jsonData, "icon");
 
        this->id = getId(jsonData, "id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "members", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                TeamMembersObjectData newData{ value.value() };
                this->members.emplace_back(std::move(newData));
            }
        }
 
        this->ownerUserId = getId(jsonData, "owner_user_id");
    }
 
    InstallParamsData::InstallParamsData(Value jsonData) {
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "scopes", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->scopes.emplace_back(Permissions{ value.getString().value().data() });
            }
        }
 
        this->permissions = getString(jsonData, "name");
    }
 
    ApplicationData::ApplicationData(Value jsonData) {
        Value object{};
        if (!getObject(object, "params", jsonData)) {
            this->params = InstallParamsData{ object };
        }
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "tags", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->tags.emplace_back(value.getString().value().data());
            }
        }
 
        this->id = getId(jsonData, "id");
 
        this->name = getString(jsonData, "name");
 
        this->icon = getString(jsonData, "icon");
 
        this->description = getString(jsonData, "description");
 
        if (!getArray(arrayValue, "rpc_origins", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->rpcOrigins.emplace_back(value.getString().value().data());
            }
        }
 
        this->botPublic = getBool(jsonData, "bot_public");
 
        this->botRequireCodeGrant = getBool(jsonData, "bot_require_code_grant");
 
        this->termsOfServiceUrl = getString(jsonData, "terms_of_service_url");
 
        this->privacyPolicyUrl = getString(jsonData, "privacy_policy_url");
 
        if (!getObject(object, "owner", jsonData)) {
            this->owner = UserData{ object };
        }
 
        if (!getObject(object, "team", jsonData)) {
            this->team = TeamObjectData{ object };
        }
 
        this->summary = getString(jsonData, "summary");
 
        this->verifyKey = getString(jsonData, "verify_key");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->primarySkuId = getString(jsonData, "primary_sku_id");
 
        this->slug = getString(jsonData, "slug");
 
        this->coverImage = getString(jsonData, "cover_image");
 
        this->flags = static_cast<ApplicationFlags>(getUint8(jsonData, "flags"));
    }
 
    AuthorizationInfoData::AuthorizationInfoData(Value jsonData) {
        Value object{};
        if (!getObject(object, "application", jsonData)) {
            this->application = ApplicationData{ object };
        }
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "features", jsonData)) {
            this->scopes.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                this->scopes.emplace_back(std::string{ value.getString().takeValue() });
            }
        }
 
        this->expires = getString(jsonData, "expires");
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
    }
 
    AccountData::AccountData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->name = getString(jsonData, "name");
    }
 
    GuildWidgetData::GuildWidgetData(Value jsonData) {
        this->enabled = getBool(jsonData, "enabled");
 
        this->channelId = getId(jsonData, "channel_id");
    };
 
    GuildWidgetImageData::GuildWidgetImageData(Value jsonData) {
        this->url = getString(jsonData, "widget_image");
    }
 
    IntegrationData::IntegrationData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->name = getString(jsonData, "name");
 
        this->type = getString(jsonData, "type");
 
        this->enabled = getBool(jsonData, "enabled");
 
        this->syncing = getBool(jsonData, "syncing");
 
        this->roleId = getId(jsonData, "role_id");
 
        this->enableEmoticons = getBool(jsonData, "enable_emoticons");
 
        this->expireBehavior = getUint32(jsonData, "expire_behavior");
 
        this->expireGracePeriod = getUint32(jsonData, "expire_grace_period");
 
        Value object{};
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
 
        if (!getObject(object, "account", jsonData)) {
            this->account = AccountData{ object };
        }
 
        if (!getObject(object, "application", jsonData)) {
            this->application = ApplicationData{ object };
        }
 
        this->syncedAt = getString(jsonData, "synced_at");
 
        this->subscriberCount = getUint32(jsonData, "subscriber_count");
 
        this->revoked = getBool(jsonData, "revoked");
    }
 
    IntegrationDataVector::IntegrationDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    IntegrationData newData{ value.value() };
                    this->integeregrations.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    OptionalAuditEntryInfoData::OptionalAuditEntryInfoData(Value jsonData) {
        this->deleteMemberDays = getString(jsonData, "delete_member_days");
 
        this->membersRemoved = getString(jsonData, "members_removed");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->messageId = getId(jsonData, "message_id");
 
        this->count = getString(jsonData, "count");
 
        this->id = getId(jsonData, "id");
 
        this->type = getString(jsonData, "type");
 
        this->roleName = getString(jsonData, "role_name");
    }
 
    AuditLogChangeData::AuditLogChangeData(Value jsonData) {
        this->newValue.value = getString(jsonData, "new_value");
 
        this->oldValue.value = getString(jsonData, "old_value");
 
        this->key = getString(jsonData, "key");
    }
 
    GuildPruneCountData::GuildPruneCountData(Value jsonData) {
        this->count = getUint32(jsonData, "pruned");
    }
 
    AuditLogEntryData::AuditLogEntryData(Value jsonData) {
        this->targetId = getId(jsonData, "target_id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "changes", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                AuditLogChangeData newData{ value.value() };
                this->changes.emplace_back(std::move(newData));
            }
        }
 
        this->userId = getId(jsonData, "user_id");
 
        this->id = getId(jsonData, "id");
        this->createdTimeStamp = this->getCreatedAtTimestamp(TimeFormat::LongDateTime);
 
        this->actionType = static_cast<AuditLogEvent>(getUint16(jsonData, "action_type"));
 
        Value object{};
        if (!getObject(object, "options", jsonData)) {
            this->options = OptionalAuditEntryInfoData{ object };
        }
 
        this->reason = getString(jsonData, "reason");
    }
 
    WelcomeScreenChannelData::WelcomeScreenChannelData(Value jsonData) {
        this->channelId = getId(jsonData, "channel_id");
 
        this->description = getString(jsonData, "description");
 
        this->emojiId = getId(jsonData, "emoji_id");
 
        this->emojiName = getString(jsonData, "emoji_name");
    }
 
    WelcomeScreenData::WelcomeScreenData(Value jsonData) {
        this->description = getString(jsonData, "description");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "welcome_channels", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                WelcomeScreenChannelData newData{ value.value() };
                this->welcomeChannels.emplace_back(std::move(newData));
            }
        }
    }
 
    StageInstanceData::StageInstanceData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->topic = getString(jsonData, "topic");
 
        this->privacyLevel = static_cast<StageInstancePrivacyLevel>(getUint8(jsonData, "privacy_level"));
 
        this->discoverableDisabled = getBool(jsonData, "discoverable_disabled");
    }
 
    StickerData::StickerData(Value jsonData) {
        this->asset = getString(jsonData, "asset");
 
        this->description = getString(jsonData, "description");
 
        this->formatType = static_cast<StickerFormatType>(getUint8(jsonData, "format_type"));
 
        uint8_t newFlags{};
        newFlags = setBool(newFlags, StickerFlags::Available, getBool(jsonData, "available"));
 
        this->flags = static_cast<StickerFlags>(newFlags);
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->id = getId(jsonData, "id");
 
        this->packId = getString(jsonData, "pack_id");
 
        this->type = static_cast<StickerType>(getUint8(jsonData, "type"));
 
        this->sortValue = getUint32(jsonData, "sort_value");
 
        this->name = getString(jsonData, "name");
 
        Value object{};
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
    }
 
    GuildPreviewData::GuildPreviewData(Value jsonData) {
        this->approximatePresenceCount = getUint32(jsonData, "approximate_presence_count");
 
        this->approximateMemberCount = getUint32(jsonData, "approximate_member_count");
 
        this->discoverySplash = getString(jsonData, "discovery_splash");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "emojis", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                EmojiData newData{ value.value() };
                this->emojis.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "stickers", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                StickerData newData{ value.value() };
                this->stickers.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "features", jsonData)) {
            this->features.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                this->features.emplace_back(value.getString().takeValue());
            }
        }
 
        this->description = getString(jsonData, "description");
 
        this->splash = getString(jsonData, "splash");
 
        this->icon = getString(jsonData, "icon");
 
        this->name = getString(jsonData, "name");
 
        this->id = getId(jsonData, "id");
    }
 
    VoiceConnection* GuildData::connectToVoice(const Snowflake guildMemberId, const Snowflake channelId, bool selfDeaf, bool selfMute,
        StreamInfo streamInfoNew) {
        if (DiscordCoreClient::getVoiceConnection(this->id) && DiscordCoreClient::getVoiceConnection(this->id)->areWeConnected()) {
            this->voiceConnectionPtr = DiscordCoreClient::getVoiceConnection(this->id);
            return this->voiceConnectionPtr;
        } else if (static_cast<Snowflake>(guildMemberId) != 0 || static_cast<Snowflake>(channelId) != 0) {
            Snowflake channelId{};
            if (static_cast<Snowflake>(guildMemberId) != 0) {
                VoiceStateDataLight dataLight{};
                dataLight.guildId = this->id;
                dataLight.userId = guildMemberId;
                auto voiceStateData = GuildMembers::getVsCache()[dataLight];
                if (voiceStateData.channelId != 0) {
                    channelId = voiceStateData.channelId;
                }
            } else {
                channelId = channelId;
            }
            uint64_t theShardId{ (this->id.operator size_t() >> 22) % this->discordCoreClient->configManager.getTotalShardCount() };
            auto theBaseSocketAgentIndex{ static_cast<int32_t>(
                floor(static_cast<double>(theShardId) / static_cast<double>(this->discordCoreClient->configManager.getTotalShardCount()) *
                    this->discordCoreClient->baseSocketAgentsMap.size())) };
            VoiceConnectInitData voiceConnectInitData{};
            voiceConnectInitData.currentShard = theShardId;
            voiceConnectInitData.streamInfo = streamInfoNew;
            voiceConnectInitData.channelId = channelId;
            voiceConnectInitData.guildId = this->id;
            voiceConnectInitData.userId = this->discordCoreClient->getBotUser().id;
            voiceConnectInitData.selfDeaf = selfDeaf;
            voiceConnectInitData.selfMute = selfMute;
            StopWatch stopWatch{ 10000ms };
            auto voiceConnection = DiscordCoreClient::getVoiceConnection(this->id);
            voiceConnection->connect(voiceConnectInitData);
            while (voiceConnection->areWeConnected()) {
                std::this_thread::sleep_for(1ms);
            }
            this->voiceConnectionPtr = voiceConnection;
            return this->voiceConnectionPtr;
        } else {
            return nullptr;
        }
    }
 
    std::string GuildData::getIconUrl() noexcept {
        std::string stringNew{ "https://cdn.discordapp.com/" };
        stringNew += "icons/" + this->id + "/" + this->icon.getIconHash() + ".png";
        return stringNew;
    }
 
    bool GuildData::areWeConnected() {
        return DiscordCoreClient::getVoiceConnection(this->id)->areWeConnected();
    }
 
    void GuildData::disconnect() {
        if (DiscordCoreClient::getVoiceConnection(this->id)) {
            UpdateVoiceStateData updateVoiceData{};
            updateVoiceData.channelId = 0;
            updateVoiceData.selfDeaf = false;
            updateVoiceData.selfMute = false;
            updateVoiceData.guildId = this->id;
            this->discordCoreClient->getBotUser().updateVoiceStatus(updateVoiceData);
            DiscordCoreClient::getVoiceConnection(this->id)->disconnect();
            this->voiceConnectionPtr = nullptr;
        }
    }
 
    GuildData::GuildData(Value jsonData) {
        uint8_t newFlags{};
        newFlags = setBool(newFlags, GuildFlags::WidgetEnabled, getBool(jsonData, "widget_enabled"));
 
        newFlags = setBool(newFlags, GuildFlags::Unavailable, getBool(jsonData, "unavailable"));
 
        newFlags = setBool(newFlags, GuildFlags::Owner, getBool(jsonData, "owner"));
 
        newFlags = setBool(newFlags, GuildFlags::Large, getUint8(jsonData, "large"));
 
        this->flags = static_cast<GuildFlags>(newFlags);
 
        this->ownerId = getId(jsonData, "owner_id");
 
        this->memberCount = getUint32(jsonData, "member_count");
 
        this->joinedAt = getString(jsonData, "joined_at");
 
        this->id = getId(jsonData, "id");
 
        this->icon = getString(jsonData, "icon");
 
        this->name = getString(jsonData, "name");
 
        this->threads.clear();
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "features", jsonData)) {
            this->threads.clear();
            for (auto value: arrayValue) {
                auto object = value.value();
                this->threads.emplace_back(getId(object, "id"));
            }
        }
 
        if (!getArray(arrayValue, "stickers", jsonData)) {
            this->stickers.clear();
            for (auto value: arrayValue) {
                this->stickers.emplace_back(getId(value.value(), "id"));
            }
        }
 
        if (!getArray(arrayValue, "guild_scheduled_events", jsonData)) {
            this->guildScheduledEvents.clear();
            for (auto value: arrayValue) {
                this->guildScheduledEvents.emplace_back(getId(value.value(), "id"));
            }
        }
 
        if (!getArray(arrayValue, "stage_instances", jsonData)) {
            this->stageInstances.clear();
            for (auto value: arrayValue) {
                this->stageInstances.emplace_back(getId(value.value(), "id"));
            }
        }
 
        if (!getArray(arrayValue, "emoji", jsonData)) {
            this->emoji.clear();
            for (auto value: arrayValue) {
                this->emoji.emplace_back(getId(value.value(), "id"));
            }
        }
 
        if (Roles::doWeCacheRoles()) {
            this->roles.clear();
            if (!getArray(arrayValue, "roles", jsonData)) {
                for (auto value: arrayValue) {
                    RoleData newData{ value.value() };
                    newData.guildId = this->id;
                    this->roles.emplace_back(newData.id);
                    Roles::insertRole(std::move(newData));
                }
            }
        }
 
        if (GuildMembers::doWeCacheGuildMembers()) {
            this->members.clear();
            GuildMemberData newData{};
            if (!getArray(arrayValue, "members", jsonData)) {
                for (auto value: arrayValue) {
                    newData = value.value();
                    newData.guildId = this->id;
                    this->members.emplace_back(newData.id);
                    GuildMembers::insertGuildMember(std::move(newData));
                }
            }
        }
 
        if (!getArray(arrayValue, "voice_states", jsonData)) {
            for (auto value: arrayValue) {
                VoiceStateDataLight dataNew{ value.value() };
                dataNew.guildId = this->id;
                GuildMembers::vsCache[dataNew] = dataNew;
            }
        }
 
        if (GuildMembers::doWeCacheGuildMembers()) {
            this->presences.clear();
            if (!getArray(arrayValue, "presences", jsonData)) {
                for (auto value: arrayValue) {
                    PresenceUpdateData newData{ value.value() };
                    newData.guildId = this->id;
                    this->presences.emplace_back(std::move(newData));
                }
            }
        }
 
        if (Channels::doWeCacheChannels()) {
            this->channels.clear();
            if (!getArray(arrayValue, "channels", jsonData)) {
                for (auto value: arrayValue) {
                    ChannelData newData{ value.value() };
                    newData.guildId = this->id;
                    this->channels.emplace_back(newData.id);
                    Channels::insertChannel(std::move(newData));
                }
            }
        }
    }
 
    GuildDataVector::GuildDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    GuildData newData{ value.value() };
                    this->guilds.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    GuildScheduledEventMetadata::GuildScheduledEventMetadata(Value jsonData) {
        this->location = getString(jsonData, "location");
    }
 
    GuildScheduledEventData::GuildScheduledEventData(Value jsonData) {
        this->privacyLevel = static_cast<GuildScheduledEventPrivacyLevel>(getUint8(jsonData, "privacy_level"));
 
        this->entityType = static_cast<GuildScheduledEventEntityType>(getUint8(jsonData, "entity_type"));
 
        this->status = static_cast<GuildScheduledEventStatus>(getUint8(jsonData, "status"));
 
        Value object{};
        if (!getObject(object, "entity_metadata", jsonData)) {
            this->entityMetadata = GuildScheduledEventMetadata{ object };
        }
 
        this->scheduledStartTime = getString(jsonData, "scheduled_start_time");
 
        this->scheduledEndTime = getString(jsonData, "scheduled_end_time");
 
        this->userCount = getUint32(jsonData, "user_count");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->creatorId = getId(jsonData, "creator_id");
 
        this->entityId = getId(jsonData, "entity_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->id = getId(jsonData, "id");
 
        this->description = getString(jsonData, "description");
 
        if (!getObject(object, "creator", jsonData)) {
            this->creator = UserData{ object };
        }
 
        this->name = getString(jsonData, "name");
    }
 
    GuildScheduledEventUserData::GuildScheduledEventUserData(Value jsonData) {
        this->guildScheduledEventId = getId(jsonData, "guild_scheduled_event_id");
 
        Value object{};
        if (!getObject(object, "member", jsonData)) {
            this->member = GuildMemberData{ object };
        }
 
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
    }
 
    GuildScheduledEventUserDataVector::GuildScheduledEventUserDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    GuildScheduledEventUserData newData{ value.value() };
                    this->guildScheduledEventUsers.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    GuildScheduledEventDataVector::GuildScheduledEventDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    GuildScheduledEventData newData{ value.value() };
                    this->guildScheduledEvents.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    InviteData::InviteData(Value jsonData) {
        this->code = getUint32(jsonData, "code");
 
        Value object{};
        if (!getObject(object, "guild", jsonData)) {
            this->guild = GuildData{ object };
        }
 
        if (!getObject(object, "channel", jsonData)) {
            this->channel = ChannelData{ object };
        }
 
        if (!getObject(object, "inviter", jsonData)) {
            this->inviter = UserData{ object };
        }
 
        this->targetType = getUint32(jsonData, "target_type");
 
        if (!getObject(object, "target_user", jsonData)) {
            this->targetUser = UserData{ object };
        }
 
        if (!getObject(object, "target_application", jsonData)) {
            this->targetApplication = ApplicationData{ object };
        }
 
        if (!getObject(object, "stage_instance", jsonData)) {
            this->stageInstance = StageInstanceData{ object };
        }
 
        if (!getObject(object, "guild_scheduled_event", jsonData)) {
            this->guildScheduledEvent = GuildScheduledEventData{ object };
        }
 
        this->approximatePresenceCount = getUint32(jsonData, "approximate_presence_count");
 
        this->approximateMemberCount = getUint32(jsonData, "approximate_member_count");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->expiresAt = getString(jsonData, "expires_at");
 
        this->uses = getUint32(jsonData, "uses");
 
        this->maxUses = getUint32(jsonData, "max_uses");
 
        this->maxAge = getUint32(jsonData, "max_age");
 
        this->temporary = getBool(jsonData, "temporary");
 
        this->createdAt = getString(jsonData, "created_at");
    }
 
    InviteDataVector::InviteDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    InviteData newData{ value.value() };
                    this->invites.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    GuildTemplateData::GuildTemplateData(Value jsonData) {
        Value object{};
        if (!getObject(object, "serialized_source_guild", jsonData)) {
            this->serializedSourceGuild = GuildData{ object };
        }
 
        if (!getObject(object, "creator", jsonData)) {
            this->creator = UserData{ object };
        }
 
        this->sourceGuildId = getString(jsonData, "source_guild_id");
 
        this->description = getString(jsonData, "description");
 
        this->usageCount = getUint32(jsonData, "usage_count");
 
        this->creatorId = getString(jsonData, "creator_id");
 
        this->createdAt = getString(jsonData, "created_at");
 
        this->updatedAt = getString(jsonData, "updated_at");
 
        this->isDirty = getBool(jsonData, "is_dirty");
 
        this->code = getString(jsonData, "code");
 
        this->name = getString(jsonData, "name");
    }
 
    GuildTemplateDataVector::GuildTemplateDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    GuildTemplateData newData{ value.value() };
                    this->guildTemplates.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    WebHookData::WebHookData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->type = static_cast<WebHookType>(getUint8(jsonData, "type"));
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->channelId = getId(jsonData, "channel_id");
 
        Value object{};
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
 
        this->name = getString(jsonData, "name");
 
        this->avatar = getString(jsonData, "avatar");
 
        this->token = getString(jsonData, "token");
 
        this->applicationId = getId(jsonData, "application_id");
 
        if (!getObject(object, "source_guild", jsonData)) {
            this->sourceGuild = GuildData{ object };
        }
 
        if (!getObject(object, "source_channel", jsonData)) {
            this->sourceChannel = ChannelData{ object };
        }
 
        this->url = getString(jsonData, "url");
    }
 
    WebHookDataVector::WebHookDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    WebHookData newData{ value.value() };
                    this->webHooks.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    AuditLogData::AuditLogData(Value jsonData) {
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "webhooks", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                WebHookData newData{ value.value() };
                this->webhooks.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "guild_scheduled_events", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                GuildScheduledEventData newData{ value.value() };
                this->guildScheduledEvents.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "auto_moderation_rules", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                AutoModerationRuleData newData{ value.value() };
                this->autoModerationRules.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "users", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                UserData newData{ value.value() };
                this->users.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "audit_log_entries", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                AuditLogEntryData newData{ value.value() };
                this->auditLogEntries.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "integrations", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                IntegrationData newData{ value.value() };
                this->integrations.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "threads", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ChannelData newData{ value.value() };
                this->threads.emplace_back(std::move(newData));
            }
        }
    }
 
    ReactionRemoveData::ReactionRemoveData(Value jsonData) {
        this->userId = getId(jsonData, "user_id");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->messageId = getId(jsonData, "message_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        Value object{};
        if (!getObject(object, "emoji", jsonData)) {
            this->emoji = EmojiData{ object };
        }
    }
 
    ApplicationCommandOptionChoiceData::ApplicationCommandOptionChoiceData(Value jsonData) {
        std::string_view string{};
        uint64_t integer{};
        bool theBool{};
        double doubleVal{};
 
        if (jsonData["value"].get(string) == Jsonifier::ErrorCode::Success) {
            this->value = static_cast<std::string>(string);
            this->type = JsonType::String;
        } else if (jsonData["value"].get(integer) == Jsonifier::ErrorCode::Success) {
            this->value = std::to_string(integer);
            this->type = JsonType::Int64;
        } else if (jsonData["value"].get(theBool) == Jsonifier::ErrorCode::Success) {
            this->type = JsonType::Bool;
            std::stringstream stream{};
            stream << std::boolalpha << theBool;
            this->value = stream.str();
        } else if (jsonData["value"].get(doubleVal) == Jsonifier::ErrorCode::Success) {
            this->type = JsonType::Float;
            this->value = std::to_string(doubleVal);
        }
 
        this->name = getString(jsonData, "name");
 
        Object map{};
        if (jsonData["name_localizations"].get(map) == Jsonifier::ErrorCode::Success) {
            this->nameLocalizations.clear();
            for (auto value: map) {
                this->nameLocalizations.emplace(value.unescapedKey().takeValue(), value.value().getString().takeValue());
            }
        }
    }
 
    bool operator==(const ApplicationCommandOptionChoiceData& lhs, const ApplicationCommandOptionChoiceData& rhs) {
        if (lhs.name != rhs.name) {
            return false;
        }
        if (lhs.nameLocalizations != rhs.nameLocalizations) {
            return false;
        }
        if (lhs.type != rhs.type) {
            return false;
        }
        if (lhs.value != rhs.value) {
            return false;
        }
        return true;
    }
 
    ApplicationCommandOptionData::ApplicationCommandOptionData(Value jsonData) {
        this->name = getString(jsonData, "name");
 
        Object map{};
        if (jsonData["name_localizations"].get(map) == Jsonifier::ErrorCode::Success) {
            this->nameLocalizations.clear();
            for (auto value: map) {
                this->nameLocalizations.emplace(value.unescapedKey().takeValue(), value.value().getString().takeValue());
            }
        }
 
        if (jsonData["description_localizations"].get(map) == Jsonifier::ErrorCode::Success) {
            this->descriptionLocalizations.clear();
            for (auto value: map) {
                this->descriptionLocalizations.emplace(value.unescapedKey().takeValue(), value.value().getString().takeValue());
            }
        }
 
        this->description = getString(jsonData, "description");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "channel_types", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->channelTypes.emplace_back(static_cast<ChannelType>(value.getUint64().value()));
            }
        }
 
        this->type = static_cast<ApplicationCommandOptionType>(getUint8(jsonData, "type"));
 
        if (this->type == ApplicationCommandOptionType::Integer) {
            this->minValue = getInt64(jsonData, "min_value");
        } else if (this->type == ApplicationCommandOptionType::Number) {
            this->minValue = getFloat(jsonData, "min_value");
        }
 
        if (this->type == ApplicationCommandOptionType::Integer) {
            this->maxValue = getInt32(jsonData, "max_value");
        } else if (this->type == ApplicationCommandOptionType::Number) {
            this->maxValue = getFloat(jsonData, "max_value");
        }
 
        this->required = getBool(jsonData, "required");
 
        this->autocomplete = getBool(jsonData, "autocomplete");
 
        if (this->type == ApplicationCommandOptionType::Sub_Command_Group || this->type == ApplicationCommandOptionType::Sub_Command) {
            if (!getArray(arrayValue, "options", jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    ApplicationCommandOptionData newData{ value.value() };
                    this->options.emplace_back(std::move(newData));
                }
            }
        }
        if (!getArray(arrayValue, "choices", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ApplicationCommandOptionChoiceData newData{ value.value() };
                this->choices.emplace_back(std::move(newData));
            }
        }
    }
 
    bool operator==(const ApplicationCommandOptionData& lhs, const ApplicationCommandOptionData& rhs) {
        if (lhs.autocomplete != rhs.autocomplete) {
            return false;
        }
        if (lhs.channelTypes != rhs.channelTypes) {
            return false;
        }
        if (lhs.description != rhs.description) {
            return false;
        }
        if (lhs.descriptionLocalizations != rhs.descriptionLocalizations) {
            return false;
        }
        if (lhs.maxValue != rhs.maxValue) {
            return false;
        }
        if (lhs.minValue != rhs.minValue) {
            return false;
        }
        if (lhs.name != rhs.name) {
            return false;
        }
        if (lhs.nameLocalizations != rhs.nameLocalizations) {
            return false;
        }
        if (lhs.options.size() != rhs.options.size()) {
            return false;
        }
        if (lhs.required != rhs.required) {
            return false;
        }
        if (lhs.type != rhs.type) {
            return false;
        }
        if (lhs.choices.size() != rhs.choices.size()) {
            return false;
        }
        for (int32_t x = 0; x < rhs.choices.size(); ++x) {
            if (lhs.choices[x] != rhs.choices[x]) {
            }
        }
        return true;
    }
 
    ApplicationCommandData::ApplicationCommandData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->defaultMemberPermissions = getString(jsonData, "default_member_permissions");
 
        this->dmPermission = getBool(jsonData, "dm_permission");
 
        this->version = getString(jsonData, "version");
 
        this->type = static_cast<ApplicationCommandType>(getUint8(jsonData, "type"));
 
        Object map{};
        if (jsonData["name_localizations"].get(map) == Jsonifier::ErrorCode::Success) {
            this->nameLocalizations.clear();
            for (auto value: map) {
                this->nameLocalizations.emplace(value.unescapedKey().takeValue(), value.value().getString().takeValue());
            }
        }
 
        if (jsonData["description_localizations"].get(map) == Jsonifier::ErrorCode::Success) {
            this->descriptionLocalizations.clear();
            for (auto value: map) {
                this->descriptionLocalizations.emplace(value.unescapedKey().takeValue(), value.value().getString().takeValue());
            }
        }
 
        this->applicationId = getId(jsonData, "application_id");
 
        this->name = getString(jsonData, "name");
 
        this->description = getString(jsonData, "description");
 
        this->version = getString(jsonData, "version");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "options", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ApplicationCommandOptionData newData{ value.value() };
                this->options.emplace_back(std::move(newData));
            }
        }
    }
 
    bool operator==(const ApplicationCommandData& lhs, const ApplicationCommandData& rhs) {
        if (lhs.description != rhs.description) {
            return false;
        }
        if (lhs.name != rhs.name) {
            return false;
        }
        if (lhs.type != rhs.type) {
            return false;
        }
        if (lhs.options.size() != rhs.options.size()) {
            return false;
        }
        for (size_t x = 0; x < lhs.options.size(); ++x) {
            if (lhs.options[x] != rhs.options[x]) {
                return false;
            }
        }
        return true;
    }
 
    TypingStartData::TypingStartData(Value jsonData) {
        this->channelId = getId(jsonData, "channel_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        Value object{};
        if (!getObject(object, "member", jsonData)) {
            this->member = GuildMemberData{ object };
        }
 
        this->userId = getId(jsonData, "user_id");
 
        this->timeStamp = getUint32(jsonData, "timestamp");
    }
 
    YouTubeFormat::YouTubeFormat(Value jsonData) {
        this->audioQuality = getString(jsonData, "audioQuality");
 
        this->averageBitrate = getUint32(jsonData, "averageBitrate");
 
        this->audioSampleRate = getString(jsonData, "audioSampleRate");
 
        this->bitrate = getUint32(jsonData, "bitrate");
 
        this->contentLength = strtoull(getString(jsonData, "contentLength"));
 
        this->fps = getUint32(jsonData, "fps");
 
        this->height = getUint32(jsonData, "height");
 
        this->height = getUint32(jsonData, "width");
 
        this->aitags = getString(jsonData, "aitags");
 
        this->itag = getUint32(jsonData, "itag");
 
        this->downloadUrl = getString(jsonData, "url");
 
        this->mimeType = getString(jsonData, "mimeType");
 
        this->quality = getString(jsonData, "quality");
 
        std::string string = getString(jsonData, "signatureCipher");
        if (string == "") {
            string = getString(jsonData, "cipher");
        }
 
        this->signatureCipher = string;
 
        auto ampersandSpFind = this->signatureCipher.find("&sp");
        if (ampersandSpFind != std::string::npos) {
            this->signature = this->signatureCipher.substr(0, ampersandSpFind);
        }
 
        auto urlFind = this->signatureCipher.find("url");
        if (urlFind != std::string::npos) {
            this->downloadUrl = this->signatureCipher.substr(urlFind + 4);
        } else {
            this->downloadUrl = getString(jsonData, "url");
        }
    }
 
    YouTubeFormatVector::YouTubeFormatVector(Value jsonData) {
        Value valueNew{};
        if (!getObject(valueNew, "streamingData", jsonData)) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, "formats", valueNew)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    YouTubeFormat newData{ value.value() };
                    this->formats.emplace_back(std::move(newData));
                }
            }
        }
 
 
        if (!getObject(valueNew, "streamingData", jsonData)) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, "adaptiveFormats", valueNew)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    YouTubeFormat newData{ value.value() };
                    this->formats.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    UserCommandInteractionData::UserCommandInteractionData(Value jsonData) {
        this->targetId = getId(jsonData, "target_id");
    }
 
    MessageCommandInteractionData::MessageCommandInteractionData(Value jsonData) {
        this->targetId = getId(jsonData, "target_id");
    }
 
    ComponentInteractionData::ComponentInteractionData(Value jsonData) {
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "values", jsonData)) {
            this->values.clear();
            for (auto iterator = arrayValue.begin(); iterator != arrayValue.end(); ++iterator) {
                this->values.emplace_back(iterator.value().operator*().getString().takeValue());
            }
        }
 
        this->customId = getString(jsonData, "custom_id");
 
        this->componentType = static_cast<ComponentType>(getUint8(jsonData, "component_type"));
    }
 
    ModalInteractionData::ModalInteractionData(Value jsonData) {
        Value theComponent{};
        if (jsonData["components"][0]["components"][0].get(theComponent) == Jsonifier::ErrorCode::Success) {
            this->value = getString(theComponent, "value");
            this->customIdSmall = getString(theComponent, "value");
        }
 
        this->customId = getString(jsonData, "custom_id");
    }
 
    AllowedMentionsData::AllowedMentionsData(Value jsonData) {
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "parse", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->parse.emplace_back(static_cast<std::string>(value.getString().value()));
            }
        }
 
        if (!getArray(arrayValue, "roles", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->roles.emplace_back(static_cast<std::string>(value.getString().value()));
            }
        }
 
        if (!getArray(arrayValue, "users", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->users.emplace_back(static_cast<std::string>(value.getString().value()));
            }
        }
 
        this->repliedUser = getBool(jsonData, "replied_user");
    }
 
    SelectOptionData::SelectOptionData(Value jsonData) {
        this->label = getString(jsonData, "label");
 
        this->value = getString(jsonData, "value");
 
        this->description = getString(jsonData, "description");
 
        Value theEmoji{};
        if (jsonData["emoji"].get(theEmoji) == Jsonifier::ErrorCode::Success) {
            this->emoji = EmojiData{ theEmoji };
        }
 
        this->_default = getBool(jsonData, "default");
    }
 
    ActionRowData::ActionRowData(Value jsonData) {
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "components", jsonData)) {
            this->components.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ComponentData newData{ value.value() };
                this->components.emplace_back(std::move(newData));
            }
        }
    }
 
    ComponentData::ComponentData(Value jsonData) {
        this->type = static_cast<ComponentType>(getUint8(jsonData, "type"));
 
        this->customId = getString(jsonData, "custom_id");
 
        this->placeholder = getString(jsonData, "placeholder");
 
        this->disabled = getBool(jsonData, "disabled");
 
        this->style = getUint32(jsonData, "style");
 
        this->label = getString(jsonData, "label");
 
        this->minLength = getUint32(jsonData, "min_length");
 
        this->maxLength = getUint32(jsonData, "max_length");
 
        this->maxValues = getUint32(jsonData, "max_values");
 
        this->maxValues = getUint32(jsonData, "min_values");
 
        this->title = getString(jsonData, "title");
 
        this->required = getBool(jsonData, "required");
 
        Value object{};
        if (!getObject(object, "emoji", jsonData)) {
            this->emoji = EmojiData{ object };
        }
 
        this->url = getString(jsonData, "url");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "select_option_data", jsonData)) {
            this->options.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                SelectOptionData newData{ value.value() };
                this->options.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "channel_types", jsonData)) {
            this->channelTypes.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ChannelType newData{ static_cast<ChannelType>(value.value().getInt64().takeValue()) };
                this->channelTypes.emplace_back(std::move(newData));
            }
        }
    }
 
    ChannelMentionData::ChannelMentionData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->type = static_cast<ChannelType>(getUint8(jsonData, "type"));
 
        this->name = getString(jsonData, "name");
    }
 
    ChannelPinsUpdateEventData::ChannelPinsUpdateEventData(Value jsonData) {
        this->guildId = getId(jsonData, "guild_id");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->lastPinTimeStamp = getString(jsonData, "last_pin_timestamp");
    }
 
    ThreadListSyncData::ThreadListSyncData(Value jsonData) {
        this->guildId = getId(jsonData, "guild_id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "channel_ids", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->channelIds.emplace_back(value.getString().takeValue());
            }
        }
 
        if (!getArray(arrayValue, "members", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ThreadMemberData newData{ value.value() };
                this->members.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "threads", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ChannelData newData{ value.value() };
                this->threads.emplace_back(std::move(newData));
            }
        }
    }
 
    ThreadMembersUpdateData::ThreadMembersUpdateData(Value jsonData) {
        this->guildId = getId(jsonData, "guild_id");
 
        this->id = getId(jsonData, "id");
 
        this->memberCount = getUint32(jsonData, "member_count");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "added_members", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ThreadMemberData newData{ value.value() };
                this->addedMembers.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "removed_member_ids", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->removedMemberIds.emplace_back(value.getString().takeValue());
            }
        }
    }
 
    MessageInteractionData::MessageInteractionData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->type = static_cast<InteractionType>(getUint8(jsonData, "type"));
 
        this->name = getString(jsonData, "name");
 
        Value object{};
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
 
        if (!getObject(object, "member", jsonData)) {
            this->member = GuildMemberData{ object };
        }
    }
 
    StickerItemData::StickerItemData(Value jsonData) {
        this->id = getId(jsonData, "id");
 
        this->name = getString(jsonData, "name");
 
        this->formatType = static_cast<StickerItemType>(getUint8(jsonData, "format_type"));
    }
 
    MessageDataOld::MessageDataOld(Value jsonData) {
        this->content = getString(jsonData, "content");
 
        this->id = getId(jsonData, "id");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        Value object{};
        if (!getObject(object, "author", jsonData)) {
            this->author = UserData{ object };
        }
 
        if (!getObject(object, "member", jsonData)) {
            this->member = GuildMemberData{ object };
        }
 
        this->timeStamp = getString(jsonData, "timestamp");
 
        this->editedTimestamp = getString(jsonData, "edited_timestamp");
 
        this->tts = getBool(jsonData, "tts");
 
        this->mentionEveryone = getBool(jsonData, "mention_everyone");
 
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "mentions", jsonData)) {
            this->mentions.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                UserData newData{ value.value() };
                this->mentions.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "mention_roles", jsonData)) {
            this->mentionRoles.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                std::string_view object = value.getString().takeValue();
                this->mentionRoles.emplace_back(std::move(object));
            }
        }
 
        if (!getArray(arrayValue, "mention_channels", jsonData)) {
            this->mentionChannels.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ChannelMentionData newChannelData{ value.value() };
                this->mentionChannels.emplace_back(std::move(newChannelData));
            }
        }
 
        if (!getArray(arrayValue, "attachments", jsonData)) {
            this->attachments.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                AttachmentData newAttachmentData{ value.value() };
                this->attachments.emplace_back(std::move(newAttachmentData));
            }
        }
 
        if (!getArray(arrayValue, "embeds", jsonData)) {
            this->embeds.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                EmbedData newEmbedData{ value.value() };
                this->embeds.emplace_back(std::move(newEmbedData));
            }
        }
 
        if (!getArray(arrayValue, "reactions", jsonData)) {
            this->reactions.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ReactionData newReactionData{ value.value() };
                this->reactions.emplace_back(std::move(newReactionData));
            }
        }
 
        this->nonce = getString(jsonData, "nonce");
 
        this->pinned = getBool(jsonData, "pinned");
 
        this->webHookId = getId(jsonData, "webhook_id");
 
        this->type = static_cast<MessageType>(getUint8(jsonData, "type"));
        if (!getObject(object, "activity", jsonData)) {
            this->activity = MessageActivityData{ object };
        }
 
        if (!getObject(object, "application", jsonData)) {
            this->application = ApplicationData{ object };
        }
 
        this->applicationId = getId(jsonData, "application_id");
 
        if (!getObject(object, "message_reference", jsonData)) {
            this->messageReference = MessageReferenceData{ object };
        }
 
        this->flags = getUint32(jsonData, "flags");
        if (!getArray(arrayValue, "sticker_items", jsonData)) {
            this->stickerItems.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                StickerItemData newReactionData{ value.value() };
                this->stickerItems.emplace_back(std::move(newReactionData));
            }
        }
 
        if (!getArray(arrayValue, "stickers", jsonData)) {
            this->stickers.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                StickerData newReactionData{ value.value() };
                this->stickers.emplace_back(std::move(newReactionData));
            }
        }
 
        if (!getObject(object, "interaction", jsonData)) {
            this->interaction = MessageInteractionData{ object };
        }
 
        if (!getArray(arrayValue, "components", jsonData)) {
            this->components.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ActionRowData newActionRowData{ value.value() };
                this->components.emplace_back(std::move(newActionRowData));
            }
        }
 
        if (!getObject(object, "thread", jsonData)) {
            this->thread = ChannelData{ object };
        }
    }
 
    MessageData::MessageData(Value jsonData) {
        this->content = getString(jsonData, "content");
 
        this->id = getId(jsonData, "id");
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        Value object{};
        if (!getObject(object, "author", jsonData)) {
            this->author = UserData{ object };
        }
 
        if (!getObject(object, "member", jsonData)) {
            this->member = GuildMemberData{ object };
        }
 
        this->timeStamp = getString(jsonData, "timestamp");
 
        this->editedTimestamp = getString(jsonData, "edited_timestamp");
 
        this->tts = getBool(jsonData, "tts");
 
        this->mentionEveryone = getBool(jsonData, "mention_everyone");
 
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "mentions", jsonData)) {
            this->mentions.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                UserData newData{ value.value() };
                this->mentions.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "mention_roles", jsonData)) {
            this->mentionRoles.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                std::string_view object = value.getString().takeValue();
                this->mentionRoles.emplace_back(std::move(object));
            }
        }
 
        if (!getArray(arrayValue, "mention_channels", jsonData)) {
            this->mentionChannels.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ChannelMentionData newChannelData{ value.value() };
                this->mentionChannels.emplace_back(std::move(newChannelData));
            }
        }
 
        if (!getArray(arrayValue, "attachments", jsonData)) {
            this->attachments.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                AttachmentData newAttachmentData{ value.value() };
                this->attachments.emplace_back(std::move(newAttachmentData));
            }
        }
 
        if (!getArray(arrayValue, "embeds", jsonData)) {
            this->embeds.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                EmbedData newEmbedData{ value.value() };
                this->embeds.emplace_back(std::move(newEmbedData));
            }
        }
 
        if (!getArray(arrayValue, "reactions", jsonData)) {
            this->reactions.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ReactionData newReactionData{ value.value() };
                this->reactions.emplace_back(std::move(newReactionData));
            }
        }
 
        this->nonce = getString(jsonData, "nonce");
 
        this->pinned = getBool(jsonData, "pinned");
 
        this->webHookId = getId(jsonData, "webhook_id");
 
        this->type = static_cast<MessageType>(getUint8(jsonData, "type"));
 
        if (!getObject(object, "activity", jsonData)) {
            this->activity = MessageActivityData{ object };
        }
 
        if (!getObject(object, "application", jsonData)) {
            this->application = ApplicationData{ object };
        }
 
        this->applicationId = getId(jsonData, "application_id");
 
        if (!getObject(object, "referenced_message", jsonData)) {
            this->referencedMessage = std::make_unique<MessageDataOld>(object);
        }
 
        if (!getObject(object, "message_reference", jsonData)) {
            this->messageReference = MessageReferenceData{ object };
        }
 
        this->flags = getUint32(jsonData, "flags");
 
        if (!getArray(arrayValue, "sticker_items", jsonData)) {
            this->stickerItems.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                StickerItemData newReactionData{ value.value() };
                this->stickerItems.emplace_back(std::move(newReactionData));
            }
        }
 
        if (!getArray(arrayValue, "stickers", jsonData)) {
            this->stickers.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                StickerData newReactionData{ value.value() };
                this->stickers.emplace_back(std::move(newReactionData));
            }
        }
 
        if (!getObject(object, "interaction", jsonData)) {
            this->interaction = MessageInteractionData{ object };
        }
 
        if (!getArray(arrayValue, "components", jsonData)) {
            this->components.clear();
            for (JsonifierResult<Value> value: arrayValue) {
                ActionRowData newActionRowData{ value.value() };
                this->components.emplace_back(std::move(newActionRowData));
            }
        }
 
        if (!getObject(object, "thread", jsonData)) {
            this->thread = ChannelData{ object };
        }
    }
 
    ResolvedData::ResolvedData(Value jsonData) {
        Object arrayValue{};
        if (jsonData["attachments"].get(arrayValue) == Jsonifier::ErrorCode::Success) {
            this->attachments.clear();
            for (JsonifierResult<Field> value: arrayValue) {
                AttachmentData newData{ value.value() };
                this->attachments[strtoull(std::string{ value.key().takeValue().raw() })] = std::move(newData);
            }
        }
        if (jsonData["users"].get(arrayValue) == Jsonifier::ErrorCode::Success) {
            this->users.clear();
            for (JsonifierResult<Field> value: arrayValue) {
                UserData newData{ value.value() };
                this->users[strtoull(std::string{ value.key().takeValue().raw() })] = std::move(newData);
            }
        }
        if (jsonData["channels"].get(arrayValue) == Jsonifier::ErrorCode::Success) {
            this->channels.clear();
            for (JsonifierResult<Field> value: arrayValue) {
                ChannelData newData{ value.value() };
                this->channels[strtoull(std::string{ value.key().takeValue().raw() })] = std::move(newData);
            }
        }
        if (jsonData["roles"].get(arrayValue) == Jsonifier::ErrorCode::Success) {
            this->roles.clear();
            for (JsonifierResult<Field> value: arrayValue) {
                RoleData newData{ value.value() };
            }
        }
 
        if (jsonData["members"].get(arrayValue) == Jsonifier::ErrorCode::Success) {
            this->members.clear();
            for (JsonifierResult<Field> value: arrayValue) {
                GuildMemberData newData{ value.value() };
                this->members[strtoull(std::string{ value.key().takeValue().raw() })] = std::move(newData);
            }
        }
 
        if (jsonData["messages"].get(arrayValue) == Jsonifier::ErrorCode::Success) {
            this->messages.clear();
            for (JsonifierResult<Field> value: arrayValue) {
                MessageData newData{ value.value() };
                this->messages[strtoull(std::string{ value.key().takeValue().raw() })] = std::move(newData);
            }
        }
    }
 
    StickerPackData::StickerPackData(Value jsonData) {
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "stickers", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                StickerData newData{ value.value() };
                this->stickers.emplace_back(std::move(newData));
            }
        }
 
        this->coverStickerId = getString(jsonData, "cover_sticker_id");
 
        this->bannerAssetId = getString(jsonData, "banner_asset_id");
 
        this->description = getString(jsonData, "description");
 
        this->name = getString(jsonData, "name");
 
        this->Id = getId(jsonData, "id");
 
        this->skuId = getString(jsonData, "sku_id");
    }
 
    StickerPackDataVector::StickerPackDataVector(Value jsonData) {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    StickerPackData newData{ value.value() };
                    this->stickerPacks.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    ConnectionData::ConnectionData(Value jsonData) {
        this->name = getString(jsonData, "name");
 
        this->id = getId(jsonData, "id");
 
        this->type = getString(jsonData, "type");
 
        this->showActivity = getBool(jsonData, "show_activity");
 
        this->friendSync = getBool(jsonData, "friend_sync");
 
        this->revoked = getBool(jsonData, "revoked");
 
        this->verified = getBool(jsonData, "verified");
 
        this->visibility = static_cast<ConnectionVisibilityTypes>(getUint8(jsonData, "visibility"));
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "integrations", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                IntegrationData newData{ value.value() };
                this->integrations.emplace_back(std::move(newData));
            }
        }
    }
 
    ApplicationCommandInteractionDataOption::ApplicationCommandInteractionDataOption(Value jsonData) {
        this->type = static_cast<ApplicationCommandOptionType>(getUint8(jsonData, "type"));
 
        this->focused = getBool(jsonData, "focused");
 
        this->name = getString(jsonData, "name");
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "options", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ApplicationCommandInteractionDataOption newData{ value.value() };
                this->options.emplace_back(std::move(newData));
            }
        }
 
        Jsonifier::Value newValue{};
        if (jsonData["value"].get(newValue) == Jsonifier::Success) {
            switch (newValue.type()) {
                case JsonType::String: {
                    this->value.type = JsonType::String;
                    this->value.value = newValue.getString().value();
                    return;
                }
                case JsonType::Uint64: {
                    this->value.type = JsonType::Uint64;
                    this->value.value = newValue.getUint64().value();
                    return;
                }
                case JsonType::Bool: {
                    this->value.type = JsonType::Bool;
                    this->value.value = newValue.getBool().value();
                    return;
                }
                case JsonType::Float: {
                    this->value.type = JsonType::Float;
                    this->value.value = newValue.getDouble().value();
                    return;
                }
            }
        }
 
        this->value.type = JsonType::Null;
    }
 
    ApplicationCommandInteractionData::ApplicationCommandInteractionData(Value jsonData) {
        this->type = static_cast<ApplicationCommandType>(getUint8(jsonData, "type"));
 
        this->name = getString(jsonData, "name");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->id = getId(jsonData, "id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "options", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                ApplicationCommandInteractionDataOption newData{ value.value() };
                this->options.emplace_back(std::move(newData));
            }
        }
 
        Value object{};
        if (!getObject(object, "resolved", jsonData)) {
            this->resolved = ResolvedData{ object };
        }
    }
 
    InteractionDataData::InteractionDataData(Value jsonData) {
        Value object{};
        if (!getObject(object, "id", jsonData)) {
            this->applicationCommandData = ApplicationCommandInteractionData{ jsonData };
        }
 
        if (!getObject(object, "target_id", jsonData)) {
            this->messageInteractionData = MessageCommandInteractionData{ jsonData };
            this->userInteractionData = UserCommandInteractionData{ jsonData };
        }
 
        uint64_t componentType{};
        if (!getObject(object, "component_type", jsonData)) {
            this->componentData = ComponentInteractionData{ jsonData };
        }
 
        if (!getObject(object, "components", jsonData)) {
            this->modalData = ModalInteractionData{ jsonData };
        }
    }
 
    InteractionData::InteractionData(Value jsonData) {
        Value object{};
        if (!getObject(object, "data", jsonData)) {
            this->data = InteractionDataData{ object };
        }
 
        this->appPermissions = getString(jsonData, "app_permissions");
 
        this->type = static_cast<InteractionType>(getUint8(jsonData, "type"));
 
        this->token = getString(jsonData, "token");
        if (!getObject(object, "member", jsonData)) {
            this->member = GuildMemberData{ object };
            this->user.id = this->member.id;
            this->user.userName = this->member.getUserData().userName;
        }
 
        if (!getObject(object, "user", jsonData)) {
            this->user = UserData{ object };
        }
 
        this->channelId = getId(jsonData, "channel_id");
 
        this->guildId = getId(jsonData, "guild_id");
 
        this->locale = getString(jsonData, "locale");
 
        this->guildLocale = getString(jsonData, "guild_locale");
 
        if (!getObject(object, "message", jsonData)) {
            this->message = MessageData{ object };
        }
 
        this->version = getUint32(jsonData, "version");
 
        this->id = getId(jsonData, "id");
 
        this->applicationId = getId(jsonData, "application_id");
    }
 
    SessionStartData::SessionStartData(Value jsonData) {
        this->maxConcurrency = getUint32(jsonData, "max_concurrency");
 
        this->remaining = getUint32(jsonData, "remaining");
 
        this->resetAfter = getUint32(jsonData, "reset_after");
 
        this->total = getUint32(jsonData, "total");
    }
 
    GatewayBotData::GatewayBotData(Value jsonData) {
        this->url = getString(jsonData, "url");
 
        this->shards = getUint32(jsonData, "shards");
 
        Value object{};
        if (!getObject(object, "session_start_limit", jsonData)) {
            this->sessionStartLimit = SessionStartData{ object };
        }
    }
 
    GuildEmojisUpdateEventData::GuildEmojisUpdateEventData(Value jsonData) {
        this->guildId = getId(jsonData, "guild_id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "emojis", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                EmojiData newData{ value.value() };
                this->emojis.emplace_back(std::move(newData));
            }
        }
    }
 
    GuildStickersUpdateEventData::GuildStickersUpdateEventData(Value jsonData) {
        this->guildId = getId(jsonData, "guild_id");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "stickers", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                StickerData newData{ value.value() };
                this->stickers.emplace_back(std::move(newData));
            }
        }
    }
 
    GuildMembersChunkEventData::GuildMembersChunkEventData(Value jsonData) {
        this->guildId = getId(jsonData, "guild_id");
 
        this->nonce = getString(jsonData, "nonce");
 
        this->chunkIndex = getUint32(jsonData, "chunk_index");
 
        this->chunkCount = getUint32(jsonData, "chunk_count");
 
        Jsonifier::Array arrayValue{};
        if (!getArray(arrayValue, "presences", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                PresenceUpdateData newData{ value.value() };
                this->presences.emplace_back(std::move(newData));
            }
        }
 
        if (!getArray(arrayValue, "not_found", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                this->notFound.emplace_back(value.getString().takeValue());
            }
        }
 
        if (!getArray(arrayValue, "members", jsonData)) {
            for (JsonifierResult<Value> value: arrayValue) {
                GuildMemberData newData{ value.value() };
                this->members.emplace_back(std::move(newData));
            }
        }
    }
 
    MediaTranscoding::MediaTranscoding(Value jsonData) {
        this->thePreset = getString(jsonData, "preset");
 
        this->theUrl = getString(jsonData, "url");
    }
 
    Song::Song(Value jsonData) {
        this->duration =
            getString(getObject(getObject(getObject(jsonData, "lengthText"), "accessibility"), "accessibilityData"), "label");
        std::string newString = getString(
            getObject(getArray(getObject(getObject(getArray(jsonData, "detailedMetadataSnippets"), 0), "snippetText"), "runs"), 0),
            "text");
        if (newString.size() > 256) {
            newString = newString.substr(0, 256);
        }
        this->description = utf8MakeValid(newString);
 
        this->thumbnailUrl = getString(getObject(getArray(getObject(jsonData, "thumbnail"), "thumbnails"), 0), "url");
        std::string newTitle01 = getString(getObject(getArray(getObject(jsonData, "title"), "runs"), 0), "text");
        if (newTitle01.size() > 256) {
            newTitle01 = newTitle01.substr(0, 256);
        }
        if (newTitle01.size() > 0) {
            this->songTitle = utf8MakeValid(newTitle01);
        }
        std::string newTitle02 = getString(getObject(jsonData, "title"), "simpleText");
        if (newTitle02.size() > 256) {
            newTitle02 = newTitle02.substr(0, 256);
        }
        if (newTitle02.size() > 0) {
            this->songTitle = utf8MakeValid(newTitle02);
        }
 
        if (newTitle01 != "") {
            this->songTitle = newTitle01;
        } else {
            this->songTitle = newTitle02;
        }
 
        this->songId = getString(jsonData, "videoId");
 
        this->trackAuthorization = getString(jsonData, "track_authorization");
 
        std::vector<MediaTranscoding> theMedia{};
        auto arrayValueNew = getArray(getObject(jsonData, "media"), "transcodings");
        if (arrayValueNew.didItSucceed) {
            for (auto value: arrayValueNew.arrayValue) {
                MediaTranscoding dataNew{ value.value() };
                theMedia.emplace_back(dataNew);
            }
        }
 
        bool isItFound{};
        for (auto& value: theMedia) {
            if (value.thePreset == "opus_0_0") {
                isItFound = true;
                this->firstDownloadUrl = value.theUrl;
                this->songId = value.theUrl;
                this->doWeGetSaved = true;
            }
        }
        bool isItFound2{};
        if (!isItFound) {
            for (auto& value: theMedia) {
                if (value.thePreset == "mp3_0_0") {
                    this->firstDownloadUrl = value.theUrl;
                    this->songId = value.theUrl;
                    isItFound2 = true;
                }
            }
        }
        if (!isItFound2 && !isItFound) {
            for (auto& value: theMedia) {
                this->firstDownloadUrl = value.theUrl;
                this->songId = value.theUrl;
            }
        }
 
        newString = getString(jsonData, "title");
        if (newString.size() > 0) {
            if (newString.size() > 256) {
                newString = newString.substr(0, 256);
            }
            this->songTitle = utf8MakeValid(newString);
        }
 
        newString = getString(jsonData, "description");
        if (newString.size() > 0) {
            if (newString.size() > 256) {
                newString = newString.substr(0, 256);
            }
            this->description = utf8MakeValid(newString);
            this->description += "...";
        }
 
        newString = getString(jsonData, "artwork_url");
        if (newString.size() > 0) {
            this->thumbnailUrl = newString;
        }
 
        newString = getString(getObject(jsonData, "user"), "avatar_url");
        if (newString.size() > 0) {
            this->thumbnailUrl = newString;
        }
 
        uint32_t theDuration = getUint32(jsonData, "duration");
        if (theDuration != 0) {
            this->duration = TimeStamp::convertMsToDurationString(theDuration);
        }
 
        newString = getString(jsonData, "permalink_url");
        if (newString.size() > 0) {
            this->viewUrl = newString;
        }
    }
 
    AttachmentData::operator Serializer() {
        Serializer data{};
        data["content_type"] = this->contentType;
        data["description"] = this->description;
        data["ephemeral"] = this->ephemeral;
        data["file_name"] = this->filename;
        data["proxy_url"] = this->proxyUrl;
        data["height"] = this->height;
        data["width"] = this->width;
        data["size"] = this->size;
        data["url"] = this->url;
        return data;
    }
 
    EmbedFieldData::operator Serializer() {
        Serializer data{};
        data["inline"] = this->Inline;
        data["value"] = escapeCharacters(this->value);
        data["name"] = escapeCharacters(this->name);
        return data;
    }
 
    EmbedData::operator Serializer() {
        Serializer data{};
        for (auto& value2: this->fields) {
            data["fields"].emplaceBack(value2.operator Serializer());
        }
        std::string realColorVal = std::to_string(this->hexColorValue.getIntColorValue());
        data["footer"]["proxy_icon_url"] = this->footer.proxyIconUrl;
        data["footer"]["icon_url"] = this->footer.iconUrl;
        data["footer"]["text"] = escapeCharacters(this->footer.text);
        data["author"]["proxy_icon_url"] = this->author.proxyIconUrl;
        data["author"]["icon_url"] = this->author.iconUrl;
        data["author"]["name"] = this->author.name;
        data["author"]["url"] = this->author.url;
        data["thumbnail"]["proxy_url"] = this->thumbnail.proxyUrl;
        data["thumbnail"]["height"] = this->thumbnail.height;
        data["thumbnail"]["width"] = this->thumbnail.width;
        data["thumbnail"]["url"] = this->thumbnail.url;
        data["image"]["proxy_url"] = this->image.proxyUrl;
        data["image"]["height"] = this->image.height;
        data["image"]["width"] = this->image.width;
        data["image"]["url"] = this->image.url;
        data["video"]["proxy_url"] = this->video.proxyUrl;
        data["video"]["height"] = this->video.height;
        data["video"]["url"] = this->video.url;
        data["video"]["width"] = this->video.width;
        data["provider"]["name"] = this->provider.name;
        data["provider"]["url"] = this->provider.url;
        data["description"] = escapeCharacters(this->description);
        data["timestamp"] = this->timeStamp;
        data["title"] = escapeCharacters(this->title);
        data["color"] = realColorVal;
        data["type"] = this->type;
        data["url"] = this->url;
        return data;
    }
 
    EmbedData& EmbedData::setAuthor(const std::string& authorName, const std::string& authorAvatarUrl) {
        this->author.name = authorName;
        this->author.iconUrl = authorAvatarUrl;
        return *this;
    }
 
    EmbedData& EmbedData::setFooter(const std::string& footerText, const std::string& footerIconUrlText) {
        this->footer.text = footerText;
        this->footer.iconUrl = footerIconUrlText;
        return *this;
    }
 
    EmbedData& EmbedData::setTimeStamp(const std::string& timeStamp) {
        this->timeStamp = timeStamp;
        return *this;
    }
 
    EmbedData& EmbedData::addField(const std::string& name, const std::string& value, bool Inline) {
        EmbedFieldData field{};
        field.Inline = Inline;
        field.value = value;
        field.name = name;
        this->fields.emplace_back(field);
        return *this;
    }
 
    EmbedData& EmbedData::setDescription(const std::string& descriptionNew) {
        this->description = descriptionNew;
        return *this;
    }
 
    EmbedData& EmbedData::setColor(const std::string& hexColorValueNew) {
        this->hexColorValue = hexColorValueNew;
        return *this;
    }
 
    EmbedData& EmbedData::setThumbnail(const std::string& thumbnailUrl) {
        this->thumbnail.url = thumbnailUrl;
        return *this;
    }
 
    EmbedData& EmbedData::setTitle(const std::string& titleNew) {
        this->title = titleNew;
        return *this;
    }
 
    EmbedData& EmbedData::setImage(const std::string& imageUrl) {
        this->image.url = imageUrl;
        return *this;
    }
 
    MessageReferenceData::operator Serializer() {
        Serializer data{};
        data["fail_if_not_exists"] = this->failIfNotExists;
        data["message_id"] = this->messageId;
        data["channel_id"] = this->channelId;
        data["guild_id"] = this->guildId;
        return data;
    }
 
    GuildApplicationCommandPermissionsDataVector::operator std::vector<GuildApplicationCommandPermissionsData>() {
        return this->guildApplicationCommandPermissionss;
    }
 
    BanDataVector::operator std::vector<BanData>() {
        return this->bans;
    }
 
    UpdateVoiceStateData::operator Serializer() {
        Serializer data{};
        data["op"] = 4;
        if (this->channelId == 0) {
            data["d"]["channel_id"] = JsonType::Null;
        } else {
            data["d"]["channel_id"] = this->channelId;
        }
        data["d"]["self_deaf"] = this->selfDeaf;
        data["d"]["self_mute"] = this->selfMute;
        data["d"]["guild_id"] = this->guildId;
        return data;
    }
 
    GuildDataVector::operator std::vector<GuildData>() {
        return this->guilds;
    }
 
    GuildScheduledEventUserDataVector::operator std::vector<GuildScheduledEventUserData>() {
        return this->guildScheduledEventUsers;
    }
 
    GuildScheduledEventDataVector::operator std::vector<GuildScheduledEventData>() {
        return this->guildScheduledEvents;
    }
 
    InviteDataVector::operator std::vector<InviteData>() {
        return this->invites;
    }
 
    GuildTemplateDataVector::operator std::vector<GuildTemplateData>() {
        return this->guildTemplates;
    }
 
    WebHookDataVector::operator std::vector<WebHookData>() {
        return this->webHooks;
    }
 
    auto AuditLogData::getAuditLogData(const Snowflake userIdOfChanger, AuditLogEvent auditLogType) {
        for (auto& value: this->auditLogEntries) {
            if (value.id == userIdOfChanger && value.actionType == auditLogType) {
                return value;
            }
        }
        return AuditLogEntryData();
    }
 
    auto AuditLogData::getAuditLogData(AuditLogEvent auditLogType, const Snowflake userIdOfTarget) {
        for (auto& value: this->auditLogEntries) {
            if (value.targetId == userIdOfTarget && value.actionType == auditLogType) {
                return value;
            }
        }
        return AuditLogEntryData();
    }
 
    ApplicationCommandOptionChoiceData::operator Serializer() {
        Serializer data{};
        data["name"] = this->name;
        data["name_localizations"] = this->nameLocalizations;
        switch (this->type) {
            case JsonType::Int64: {
                data["value"] = uint64_t{ stoull(this->value) };
                break;
            }
            case JsonType::Uint64: {
                data["value"] = uint64_t{ stoull(this->value) };
                break;
            }
            case JsonType::Float: {
                data["value"] = double{ stod(this->value) };
                break;
            }
            case JsonType::Bool: {
                if (this->value == "false") {
                    data["value"] = bool{};
                } else {
                    data["value"] = bool{ true };
                }
                break;
            }
            case JsonType::String: {
                data["value"] = this->value;
                break;
            }
            case JsonType::Null: {
                data["value"] = this->value;
                break;
            }
        }
        return data;
    }
 
    ApplicationCommandOptionData::operator Serializer() {
        Serializer data{};
        if (this->type == ApplicationCommandOptionType::Channel) {
            data["channel_types"] = this->channelTypes;
        }
        if (this->type != ApplicationCommandOptionType::Sub_Command && this->type != ApplicationCommandOptionType::Sub_Command_Group) {
            data["required"] = this->required;
        }
        if (this->descriptionLocalizations.size() > 0) {
            data["description_localizations"] = this->descriptionLocalizations;
        }
        if (this->nameLocalizations.size() > 0) {
            data["name_localizations"] = this->nameLocalizations;
        }
        data["description"] = this->description;
        if (this->minValue != std::numeric_limits<int32_t>::max()) {
            data["min_value"] = this->minValue;
        }
        if (this->maxValue != std::numeric_limits<int32_t>::min()) {
            data["max_value"] = this->maxValue;
        }
        data["required"] = this->required;
        data["name"] = this->name;
        data["type"] = this->type;
        for (auto& value: this->choices) {
            data["choices"].emplaceBack(value.operator Serializer());
        }
        if (this->choices.size() == 0) {
            data["autocomplete"] = this->autocomplete;
        }
        for (auto& value: this->options) {
            data["options"].emplaceBack(value.operator Serializer());
        }
        return data;
    }
 
    ThreadMemberDataVector::operator std::vector<ThreadMemberData>() {
        return this->threadMembers;
    }
 
    YouTubeFormatVector::operator std::vector<YouTubeFormat>() {
        return this->formats;
    }
 
    AudioFrameData& AudioFrameData::operator+=(std::basic_string_view<std::byte> other) noexcept {
        if (this->data.size() < this->currentSize + other.size()) {
            this->data.resize(other.size() + this->currentSize);
        }
        std::copy(other.data(), other.data() + other.size(), this->data.data() + this->currentSize);
        this->currentSize += other.size();
        this->type = AudioFrameType::RawPCM;
        return *this;
    }
 
    AudioFrameData& AudioFrameData::operator+=(std::byte character) {
        this->currentSize++;
        this->data.push_back(character);
        return *this;
    }
 
    bool operator==(const AudioFrameData& lhs, const AudioFrameData& rhs) {
        if (lhs.data != rhs.data) {
            return false;
        }
        if (lhs.currentSize != rhs.currentSize) {
            return false;
        }
        if (lhs.guildMemberId != rhs.guildMemberId) {
            return false;
        }
        if (lhs.type != rhs.type) {
            return false;
        }
        return true;
    }
 
    AudioFrameData& AudioFrameData::operator=(AudioFrameData&& other) noexcept {
        if (this->data.size() < other.data.size() + this->currentSize) {
            this->data.resize(other.data.size() + this->currentSize);
        }
        std::copy(other.data.data(), other.data.data() + other.data.size(), this->data.data() + this->currentSize);
        this->currentSize += other.data.size();
        this->guildMemberId = std::move(other.guildMemberId);
        this->type = other.type;
        other.currentSize = 0;
        other.type = AudioFrameType::Unset;
        return *this;
    }
 
    AudioFrameData::AudioFrameData(AudioFrameData&& other) noexcept {
        *this = std::move(other);
    }
 
    void AudioFrameData::clearData() noexcept {
        this->type = AudioFrameType::Unset;
        this->guildMemberId = 0;
        this->currentSize = 0;
        this->data.clear();
    }
 
    AllowedMentionsData::operator Serializer() {
        Serializer data{};
        for (auto& value: this->parse) {
            data["parse"].emplaceBack(value);
        }
        for (auto& value: this->roles) {
            data["roles"].emplaceBack(value);
        }
        for (auto& value: this->users) {
            data["users"].emplaceBack(value);
        }
        data["replied_user"] = this->repliedUser;
        return data;
    }
 
    ActionRowData::operator Serializer() {
        Serializer data{};
        data["type"] = 1;
        if (this->components.size() > 0) {
            for (auto& valueNew: this->components) {
                if (valueNew.type == ComponentType::Button) {
                    Serializer component{};
                    if (valueNew.emoji.name != "") {
                        component["emoji"]["animated"] = valueNew.emoji.animated;
                        component["emoji"]["name"] = std::string{ valueNew.emoji.name };
                        if (valueNew.emoji.id != 0) {
                            component["emoji"]["id"] = valueNew.emoji.id;
                        }
                    }
                    component["custom_id"] = valueNew.customId;
                    component["disabled"] = valueNew.disabled;
                    component["label"] = valueNew.label;
                    component["style"] = valueNew.style;
                    component["type"] = valueNew.type;
                    component["url"] = valueNew.url;
                    data["components"].emplaceBack(component);
                } else if (valueNew.type == ComponentType::String_Select || valueNew.type == ComponentType::User_Select ||
                    valueNew.type == ComponentType::Role_Select || valueNew.type == ComponentType::Mentionable_Select ||
                    valueNew.type == ComponentType::Channel_Select) {
                    Serializer component{};
                    for (auto& value01: valueNew.options) {
                        Serializer option{};
                        if (valueNew.emoji.name != "") {
                            component["emoji"]["animated"] = valueNew.emoji.animated;
                            component["emoji"]["name"] = std::string{ valueNew.emoji.name };
                            if (valueNew.emoji.id != 0) {
                                component["emoji"]["id"] = valueNew.emoji.id;
                            }
                        }
                        option["description"] = value01.description;
                        option["default"] = value01._default;
                        option["label"] = value01.label;
                        option["value"] = value01.value;
                        component["options"].emplaceBack(option);
                    };
                    component["placeholder"] = valueNew.placeholder;
                    component["max_values"] = valueNew.maxValues;
                    component["min_values"] = valueNew.minValues;
                    component["custom_id"] = valueNew.customId;
                    component["disabled"] = valueNew.disabled;
                    component["type"] = valueNew.type;
                    data["components"].emplaceBack(component);
 
                } else if (valueNew.type == ComponentType::Text_Input) {
                    Serializer component{};
                    component["placeholder"] = valueNew.placeholder;
                    component["min_length"] = valueNew.minLength;
                    component["max_length"] = valueNew.maxLength;
                    component["custom_id"] = valueNew.customId;
                    component["required"] = valueNew.required;
                    component["style"] = valueNew.style;
                    component["label"] = valueNew.label;
                    component["value"] = valueNew.value;
                    component["type"] = valueNew.type;
                    data["components"].emplaceBack(component);
                }
            }
        }
        return data;
    }
 
    MessageData& MessageData::operator=(const MessageData& other) {
        if (this != &other) {
            if (other.referencedMessage) {
                *this->referencedMessage = *other.referencedMessage;
            }
            this->messageReference = other.messageReference;
            this->mentionEveryone = other.mentionEveryone;
            this->mentionChannels = other.mentionChannels;
            this->editedTimestamp = other.editedTimestamp;
            this->applicationId = other.applicationId;
            this->stickerItems = other.stickerItems;
            this->mentionRoles = other.mentionRoles;
            this->application = other.application;
            this->interaction = other.interaction;
            this->attachments = other.attachments;
            this->components = other.components;
            this->timeStamp = other.timeStamp;
            this->channelId = other.channelId;
            this->webHookId = other.webHookId;
            this->reactions = other.reactions;
            this->activity = other.activity;
            this->mentions = other.mentions;
            this->stickers = other.stickers;
            this->content = other.content;
            this->guildId = other.guildId;
            this->member = other.member;
            this->thread = other.thread;
            this->pinned = other.pinned;
            this->author = other.author;
            this->embeds = other.embeds;
            this->nonce = other.nonce;
            this->flags = other.flags;
            this->type = other.type;
            this->tts = other.tts;
            this->id = other.id;
        }
        return *this;
    }
 
    MessageData::MessageData(const MessageData& other) {
        *this = other;
    }
 
    StickerPackDataVector::operator std::vector<StickerPackData>() {
        return this->stickerPacks;
    }
 
    ConnectionDataVector::operator std::vector<ConnectionData>() {
        return this->connections;
    }
 
    ConnectionDataVector::ConnectionDataVector(Value jsonData) noexcept {
        if (jsonData.type() != Jsonifier::JsonType::Null) {
            Jsonifier::Array arrayValue{};
            if (!getArray(arrayValue, jsonData)) {
                for (JsonifierResult<Value> value: arrayValue) {
                    ConnectionData newData{ value.value() };
                    this->connections.emplace_back(std::move(newData));
                }
            }
        }
    }
 
    VoiceRegionDataVector::operator std::vector<VoiceRegionData>() {
        return this->voiceRegions;
    }
 
    IntegrationDataVector::operator std::vector<IntegrationData>() {
        return this->integeregrations;
    }
 
    InputEventData& InputEventData::operator=(InputEventData&& other) noexcept {
        if (this != &other) {
            *this->interactionData = std::move(*other.interactionData);
            this->responseType = other.responseType;
        }
        return *this;
    }
 
    InputEventData::InputEventData(InputEventData&& other) noexcept {
        *this = std::move(other);
    }
 
    InputEventData& InputEventData::operator=(const InputEventData& other) noexcept {
        if (this != &other) {
            *this->interactionData = *other.interactionData;
            this->responseType = other.responseType;
        }
        return *this;
    }
 
    InputEventData::InputEventData(const InputEventData& other) noexcept {
        *this = other;
    }
 
    InputEventData& InputEventData::operator=(const InteractionData& other) noexcept {
        *this->interactionData = other;
        return *this;
    }
 
    InputEventData::InputEventData(const InteractionData& interactionData) noexcept {
        *this = interactionData;
    }
 
    UserData InputEventData::getUserData() const {
        UserData returnData{};
        returnData.id = this->interactionData->user.id;
        returnData = Users::getCachedUser({ .userId = returnData.id });
        return this->interactionData->user;
    }
 
    ChannelData InputEventData::getChannelData() const {
        ChannelData returnData{};
        returnData.id = this->interactionData->channelId;
        returnData = Channels::getCachedChannel({ returnData.id });
        return returnData;
    }
 
    GuildMemberData InputEventData::getGuildMemberData() const {
        GuildMemberData returnData{ this->interactionData->member };
        returnData = GuildMembers::getCachedGuildMember({ .guildMemberId = returnData.id, .guildId = this->interactionData->guildId });
        return returnData;
    }
 
    GuildData InputEventData::getGuildData() const {
        GuildData returnData{};
        returnData.id = this->interactionData->guildId;
        returnData = Guilds::getCachedGuild({ .guildId = this->interactionData->guildId });
        return returnData;
    }
 
    InteractionData InputEventData::getInteractionData() const {
        return *this->interactionData;
    }
 
    MessageData InputEventData::getMessageData() const {
        return this->interactionData->message;
    }
 
    RespondToInputEventData& RespondToInputEventData::operator=(const InteractionData& dataPackage) {
        this->applicationId = dataPackage.applicationId;
        this->interactionToken = dataPackage.token;
        this->messageId = dataPackage.message.id;
        this->channelId = dataPackage.channelId;
        this->interactionId = dataPackage.id;
        this->eventType = dataPackage.type;
        return *this;
    };
 
    RespondToInputEventData::RespondToInputEventData(const InteractionData& dataPackage) {
        *this = dataPackage;
    }
 
    RespondToInputEventData& RespondToInputEventData::operator=(const InputEventData& dataPackage) {
        this->applicationId = dataPackage.getInteractionData().applicationId;
        this->interactionToken = dataPackage.getInteractionData().token;
        this->interactionId = dataPackage.getInteractionData().id;
        this->channelId = dataPackage.getChannelData().id;
        this->messageId = dataPackage.getMessageData().id;
        return *this;
    }
 
    RespondToInputEventData::RespondToInputEventData(const InputEventData& dataPackage) {
        *this = dataPackage;
    }
 
    RespondToInputEventData& RespondToInputEventData::addButton(bool disabled, const std::string& customIdNew,
        const std::string& buttonLabel, ButtonStyle buttonStyle, const std::string& emojiName, Snowflake emojiId, const std::string& url) {
        if (this->components.size() == 0) {
            ActionRowData actionRowData;
            this->components.emplace_back(actionRowData);
        }
        if (this->components.size() < 5) {
            if (this->components[this->components.size() - 1].components.size() < 5) {
                ComponentData component;
                component.type = ComponentType::Button;
                component.emoji.name = emojiName;
                component.label = buttonLabel;
                component.style = static_cast<int32_t>(buttonStyle);
                component.customId = customIdNew;
                component.disabled = disabled;
                component.emoji.id = emojiId;
                component.url = url;
                this->components[this->components.size() - 1].components.emplace_back(component);
            } else if (this->components[this->components.size() - 1].components.size() == 5) {
                ActionRowData actionRowData;
                this->components.emplace_back(actionRowData);
            }
        }
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::addSelectMenu(bool disabled, const std::string& customIdNew,
        std::vector<SelectOptionData> options, const std::string& placeholder, int32_t maxValues, int32_t minValues, SelectMenuType type,
        std::vector<ChannelType> channelTypes) {
        if (this->components.size() == 0) {
            ActionRowData actionRowData;
            this->components.emplace_back(actionRowData);
        }
        if (this->components.size() < 5) {
            if (this->components[this->components.size() - 1].components.size() < 5) {
                ComponentData componentData;
                componentData.type = static_cast<ComponentType>(type);
                componentData.channelTypes = channelTypes;
                componentData.placeholder = placeholder;
                componentData.customId = customIdNew;
                componentData.maxValues = maxValues;
                componentData.minValues = minValues;
                componentData.disabled = disabled;
                componentData.options = options;
                this->components[this->components.size() - 1].components.emplace_back(componentData);
            } else if (this->components[this->components.size() - 1].components.size() == 5) {
                ActionRowData actionRowData;
                this->components.emplace_back(actionRowData);
            }
        }
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::addModal(const std::string& topTitleNew, const std::string& topCustomIdNew,
        const std::string& titleNew, const std::string& customIdNew, bool required, int32_t minLength, int32_t maxLength,
        TextInputStyle inputStyle, const std::string& label, const std::string& placeholder) {
        this->title = topTitleNew;
        this->customId = topCustomIdNew;
        if (this->components.size() == 0) {
            ActionRowData actionRowData;
            this->components.emplace_back(actionRowData);
        }
        if (this->components.size() < 5) {
            if (this->components[this->components.size() - 1].components.size() < 5) {
                ComponentData component{};
                component.type = ComponentType::Text_Input;
                component.customId = customIdNew;
                component.style = static_cast<int32_t>(inputStyle);
                component.title = titleNew;
                component.maxLength = maxLength;
                component.minLength = minLength;
                component.label = label;
                component.required = required;
                component.placeholder = placeholder;
                this->components[this->components.size() - 1].components.emplace_back(component);
            } else if (this->components[this->components.size() - 1].components.size() == 5) {
                ActionRowData actionRowData;
                this->components.emplace_back(actionRowData);
            }
        }
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::addFile(File theFile) {
        this->files.emplace_back(theFile);
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::addAllowedMentions(AllowedMentionsData dataPackage) {
        this->allowedMentions = dataPackage;
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::setResponseType(InputEventResponseType typeNew) {
        this->type = typeNew;
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::addComponentRow(ActionRowData dataPackage) {
        this->components.emplace_back(dataPackage);
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::addMessageEmbed(EmbedData dataPackage) {
        this->embeds.emplace_back(dataPackage);
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::addContent(const std::string& dataPackage) {
        this->content = dataPackage;
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::setTTSStatus(bool enabledTTs) {
        this->tts = enabledTTs;
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::setAutoCompleteChoice(Serializer value, const std::string& theName,
        std::unordered_map<std::string, std::string> theNameLocalizations) {
        ApplicationCommandOptionChoiceData choiceData{};
        choiceData.nameLocalizations = theNameLocalizations;
        choiceData.name = theName;
        switch (value.getType()) {
            case JsonType::String: {
                choiceData.type = JsonType::String;
                break;
            }
            case JsonType::Float: {
                choiceData.type = JsonType::Float;
                break;
            }
            case JsonType::Uint64: {
                choiceData.type = JsonType::Uint64;
                break;
            }
            case JsonType::Int64: {
                choiceData.type = JsonType::Int64;
                break;
            }
            case JsonType::Bool: {
                choiceData.type = JsonType::Bool;
                break;
            }
        }
        value.refreshString(JsonifierSerializeType::Json);
        choiceData.value = value.operator std::string();
        this->choices.emplace_back(choiceData);
        return *this;
    }
 
    RespondToInputEventData& RespondToInputEventData::setTargetUserID(const Snowflake targetUserIdNew) {
        this->targetUserId = targetUserIdNew;
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::addButton(bool disabled, const std::string& customIdNew, const std::string& buttonLabel,
        ButtonStyle buttonStyle, const std::string& emojiName, Snowflake emojiId, const std::string& url) {
        if (this->components.size() == 0) {
            ActionRowData actionRowData;
            this->components.emplace_back(actionRowData);
        }
        if (this->components.size() < 5) {
            if (this->components[this->components.size() - 1].components.size() < 5) {
                ComponentData component;
                component.type = ComponentType::Button;
                component.emoji.name = emojiName;
                component.label = buttonLabel;
                component.style = static_cast<int32_t>(buttonStyle);
                component.customId = customIdNew;
                component.disabled = disabled;
                component.emoji.id = emojiId;
                component.url = url;
                this->components[this->components.size() - 1].components.emplace_back(component);
            } else if (this->components[this->components.size() - 1].components.size() == 5) {
                ActionRowData actionRowData;
                this->components.emplace_back(actionRowData);
            }
        }
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::addSelectMenu(bool disabled, const std::string& customIdNew,
        std::vector<SelectOptionData> options, const std::string& placeholder, int32_t maxValues, int32_t minValues, SelectMenuType type,
        std::vector<ChannelType> channelTypes) {
        if (this->components.size() == 0) {
            ActionRowData actionRowData;
            this->components.emplace_back(actionRowData);
        }
        if (this->components.size() < 5) {
            if (this->components[this->components.size() - 1].components.size() < 5) {
                ComponentData componentData;
                componentData.type = static_cast<ComponentType>(type);
                componentData.channelTypes = channelTypes;
                componentData.placeholder = placeholder;
                componentData.customId = customIdNew;
                componentData.maxValues = maxValues;
                componentData.minValues = minValues;
                componentData.disabled = disabled;
                componentData.options = options;
                this->components[this->components.size() - 1].components.emplace_back(componentData);
            } else if (this->components[this->components.size() - 1].components.size() == 5) {
                ActionRowData actionRowData;
                this->components.emplace_back(actionRowData);
            }
        }
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::addModal(const std::string& topTitleNew, const std::string& topCustomIdNew,
        const std::string& titleNew, const std::string& customIdNew, bool required, int32_t minLength, int32_t maxLength,
        TextInputStyle inputStyle, const std::string& label, const std::string& placeholder) {
        this->title = topTitleNew;
        this->customId = topCustomIdNew;
        if (this->components.size() == 0) {
            ActionRowData actionRowData;
            this->components.emplace_back(actionRowData);
        }
        if (this->components.size() < 5) {
            if (this->components[this->components.size() - 1].components.size() < 5) {
                ComponentData component{};
                component.type = ComponentType::Text_Input;
                component.customId = customIdNew;
                component.style = static_cast<int32_t>(inputStyle);
                component.title = titleNew;
                component.maxLength = maxLength;
                component.minLength = minLength;
                component.label = label;
                component.required = required;
                component.placeholder = placeholder;
                this->components[this->components.size() - 1].components.emplace_back(component);
            } else if (this->components[this->components.size() - 1].components.size() == 5) {
                ActionRowData actionRowData;
                this->components.emplace_back(actionRowData);
            }
        }
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::addFile(File theFile) {
        this->files.emplace_back(theFile);
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::addAllowedMentions(AllowedMentionsData dataPackage) {
        this->allowedMentions = dataPackage;
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::addComponentRow(ActionRowData dataPackage) {
        this->components.emplace_back(dataPackage);
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::addMessageEmbed(EmbedData dataPackage) {
        this->embeds.emplace_back(dataPackage);
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::addContent(const std::string& dataPackage) {
        this->content = dataPackage;
        return *this;
    }
 
    MessageResponseBase& MessageResponseBase::setTTSStatus(bool enabledTTs) {
        this->tts = enabledTTs;
        return *this;
    }
 
    InteractionResponseData& InteractionResponseData::operator=(const RespondToInputEventData& other) {
        this->data.allowedMentions = other.allowedMentions;
        this->data.components = other.components;
        this->data.customId = other.customId;
        this->data.choices = other.choices;
        this->data.content = other.content;
        this->data.embeds = other.embeds;
        this->data.title = other.title;
        this->data.files = other.files;
        this->data.flags = other.flags;
        this->data.tts = other.tts;
        return *this;
    }
 
    InteractionResponseData::InteractionResponseData(const RespondToInputEventData& other) {
        *this = other;
    }
 
    InteractionResponseData::operator Serializer() {
        Serializer data{};
        data["type"] = this->type;
        if (this->data.attachments.size() > 0) {
            for (auto& value: this->data.attachments) {
                data["data"]["attachments"].emplaceBack(value);
            }
        }
        if (this->data.components.size() == 0) {
            data["data"]["components"].emplaceBack(ActionRowData{});
            data["data"]["components"].getValue<Serializer::ArrayType>().clear();
        } else {
            for (auto& value: this->data.components) {
                data["data"]["components"].emplaceBack(value);
            }
        }
        if (this->data.allowedMentions.parse.size() > 0 || this->data.allowedMentions.roles.size() > 0 ||
            this->data.allowedMentions.users.size() > 0) {
            data["data"]["allowed_mentions"] = this->data.allowedMentions.operator Serializer();
        }
        if (this->data.choices.size() > 0) {
            for (auto& value: this->data.choices) {
                Serializer valueNew{};
                valueNew["name"] = value.name;
                valueNew["name_localizations"] = value.nameLocalizations;
                valueNew["value"] = value.value;
                data["data"]["choices"].emplaceBack(value);
            }
        }
        if (this->data.embeds.size() == 0) {
            data["data"]["embeds"].emplaceBack(EmbedData{});
            data["data"]["embeds"].getValue<Serializer::ArrayType>().clear();
        } else {
            for (auto& value: this->data.embeds) {
                data["data"]["embeds"].emplaceBack(value);
            }
        }
        if (this->data.customId != "") {
            data["data"]["custom_id"] = this->data.customId;
        }
        if (this->data.content != "") {
            data["data"]["content"] = this->data.content;
        }
        if (this->data.title != "") {
            data["data"]["title"] = this->data.title;
        }
        data["data"]["flags"] = this->data.flags;
        data["data"]["tts"] = this->data.tts;
        return data;
    }
 
    void parseCommandDataOption(std::unordered_map<std::string, JsonStringValue>& values, ApplicationCommandInteractionDataOption& data) {
        JsonStringValue valueNew{};
        valueNew.type = data.value.type;
        valueNew.value = data.value.value;
        values.insert_or_assign(data.name, valueNew);
        for (auto& value: data.options) {
            parseCommandDataOption(values, value);
        }
    }
 
    CommandData& CommandData::operator=(const CommandData& other) noexcept {
        this->subCommandGroupName = other.subCommandGroupName;
        this->subCommandName = other.subCommandName;
        this->commandName = other.commandName;
        this->optionsArgs = other.optionsArgs;
        this->eventData = other.eventData;
        return *this;
    }
 
    CommandData::CommandData(const CommandData& other) noexcept {
        *this = other;
    }
 
    CommandData::CommandData(InputEventData inputEventData) {
        if (inputEventData.interactionData->data.applicationCommandData.name != "") {
            this->commandName = inputEventData.interactionData->data.applicationCommandData.name;
        }
        if (inputEventData.interactionData->data.messageInteractionData.targetId != 0) {
            this->optionsArgs.values.emplace("target_id",
                JsonStringValue{ .value = inputEventData.interactionData->data.messageInteractionData.targetId, .type = JsonType::String });
        } else if (inputEventData.interactionData->data.userInteractionData.targetId != 0) {
            this->optionsArgs.values.emplace("target_id",
                JsonStringValue{ .value = inputEventData.interactionData->data.userInteractionData.targetId, .type = JsonType::String });
        }
        this->eventData = inputEventData;
        for (auto& value: this->eventData.interactionData->data.applicationCommandData.options) {
            JsonStringValue valueNew{};
            valueNew.type = value.value.type;
            valueNew.value = value.value.value;
            this->optionsArgs.values.insert_or_assign(value.name, valueNew);
            parseCommandDataOption(this->optionsArgs.values, value);
        }
        for (auto& value: inputEventData.interactionData->data.applicationCommandData.options) {
            if (value.type == ApplicationCommandOptionType::Sub_Command) {
                this->subCommandName = value.name;
            }
            if (value.type == ApplicationCommandOptionType::Sub_Command_Group) {
                this->subCommandGroupName = value.name;
            }
        }
    }
 
    InteractionData CommandData::getInteractionData() noexcept {
        return *this->eventData.interactionData;
    }
 
    GuildMemberData CommandData::getGuildMemberData() noexcept {
        return this->eventData.getGuildMemberData();
    }
 
    ChannelData CommandData::getChannelData() noexcept {
        return this->eventData.getChannelData();
    }
 
    MessageData CommandData::getMessageData() noexcept {
        return this->eventData.getMessageData();
    }
 
    GuildData CommandData::getGuildData() noexcept {
        return this->eventData.getGuildData();
    }
 
    UserData CommandData::getUserData() noexcept {
        return this->eventData.getUserData();
    }
 
    std::string CommandData::getCommandName() noexcept {
        return this->commandName;
    }
 
    std::string CommandData::getSubCommandName() noexcept {
        return this->subCommandName;
    }
 
    std::string CommandData::getSubCommandGroupName() noexcept {
        return this->subCommandGroupName;
    }
 
    JsonifierValue CommandData::getCommandArguments() noexcept {
        return this->optionsArgs;
    }
 
    InputEventData CommandData::getInputEventData() noexcept {
        return this->eventData;
    }
 
    BaseFunctionArguments::BaseFunctionArguments(CommandData commanddataNew, DiscordCoreClient* discordCoreClientNew)
        : CommandData(commanddataNew) {
        this->discordCoreClient = discordCoreClientNew;
    }
 
    MoveThroughMessagePagesData moveThroughMessagePages(const std::string& userID, InputEventData originalEvent, uint32_t currentPageIndex,
        const std::vector<EmbedData>& messageEmbeds, bool deleteAfter, uint32_t waitForMaxMs, bool returnResult) {
        MoveThroughMessagePagesData returnData{};
        uint32_t newCurrentPageIndex = currentPageIndex;
        StopWatch stopWatch{ Milliseconds{ waitForMaxMs } };
        auto createResponseData = std::make_unique<CreateInteractionResponseData>(originalEvent);
        auto interactionResponse = std::make_unique<RespondToInputEventData>(originalEvent);
        auto embedData = std::make_unique<EmbedData>();
        embedData->setColor("FEFEFE");
        embedData->setTitle("__**Permissions Issue:**__");
        embedData->setTimeStamp(getTimeAndDate());
        embedData->setDescription("Sorry, but that button can only be pressed by <@" + userID + ">!");
        createResponseData->addMessageEmbed(*embedData);
        createResponseData->setResponseType(InteractionCallbackType::Channel_Message_With_Source);
        if (messageEmbeds.size() > 0) {
            interactionResponse->addMessageEmbed(messageEmbeds[currentPageIndex]);
        }
        if (returnResult) {
            interactionResponse->addButton(false, "select", "Select", ButtonStyle::Success, "✅");
        }
        interactionResponse->addButton(false, "backwards", "Prev Page", ButtonStyle::Primary, "◀️");
        interactionResponse->addButton(false, "forwards", "Next Page", ButtonStyle::Primary, "▶️");
        interactionResponse->addButton(false, "exit", "Exit", ButtonStyle::Danger, "❌");
        interactionResponse->setResponseType(InputEventResponseType::Edit_Interaction_Response);
        originalEvent = InputEvents::respondToInputEventAsync(*interactionResponse).get();
        while (!stopWatch.hasTimePassed()) {
            std::this_thread::sleep_for(1ms);
            std::unique_ptr<ButtonCollector> button{ std::make_unique<ButtonCollector>(originalEvent) };
            std::vector<ButtonResponseData> buttonIntData{
                button->collectButtonData(false, waitForMaxMs, 1, *createResponseData, Snowflake{ stoull(userID) }).get()
            };
            std::unique_ptr<InteractionData> interactionData{ std::make_unique<InteractionData>() };
            if (buttonIntData.size() == 0 || buttonIntData.at(0).buttonId == "empty" || buttonIntData.at(0).buttonId == "exit") {
                std::unique_ptr<RespondToInputEventData> dataPackage02{ std::make_unique<RespondToInputEventData>(originalEvent) };
                if (buttonIntData.at(0).buttonId == "empty") {
                    *dataPackage02 = originalEvent;
                } else {
                    interactionData = std::make_unique<InteractionData>(buttonIntData.at(0));
                    *dataPackage02 = RespondToInputEventData{ *interactionData };
                }
 
                dataPackage02->addMessageEmbed(messageEmbeds[newCurrentPageIndex]);
                for (size_t x = 0; x < originalEvent.getMessageData().components.size(); ++x) {
                    ActionRowData actionRow{};
                    for (size_t y = 0; y < originalEvent.getMessageData().components[x].components.size(); ++y) {
                        auto component = originalEvent.getMessageData().components[x].components[y];
                        component.disabled = true;
                        actionRow.components.push_back(component);
                    }
                    dataPackage02->addComponentRow(actionRow);
                }
                if (deleteAfter == true) {
                    InputEventData dataPackage03{ originalEvent };
                    InputEvents::deleteInputEventResponseAsync(dataPackage03);
                } else {
                    dataPackage02->setResponseType(InputEventResponseType::Edit_Interaction_Response);
                    InputEvents::respondToInputEventAsync(*dataPackage02).get();
                }
                MoveThroughMessagePagesData dataPackage03{};
                dataPackage03.inputEventData = originalEvent;
                dataPackage03.buttonId = "exit";
                return dataPackage03;
            } else if (buttonIntData.at(0).buttonId == "forwards" || buttonIntData.at(0).buttonId == "backwards") {
                if (buttonIntData.at(0).buttonId == "forwards" && (newCurrentPageIndex == (messageEmbeds.size() - 1))) {
                    newCurrentPageIndex = 0;
                } else if (buttonIntData.at(0).buttonId == "forwards" && (newCurrentPageIndex < messageEmbeds.size())) {
                    ++newCurrentPageIndex;
                } else if (buttonIntData.at(0).buttonId == "backwards" && (newCurrentPageIndex > 0)) {
                    --newCurrentPageIndex;
                } else if (buttonIntData.at(0).buttonId == "backwards" && (newCurrentPageIndex == 0)) {
                    newCurrentPageIndex = static_cast<uint32_t>(messageEmbeds.size()) - 1;
                }
                interactionData = std::make_unique<InteractionData>(buttonIntData.at(0));
                auto dataPackage = RespondToInputEventData{ *interactionData };
                dataPackage.setResponseType(InputEventResponseType::Edit_Interaction_Response);
                for (size_t x = 0; x < originalEvent.getMessageData().components.size(); ++x) {
                    ActionRowData actionRow{};
                    for (size_t y = 0; y < originalEvent.getMessageData().components[x].components.size(); ++y) {
                        auto component = originalEvent.getMessageData().components[x].components[y];
                        component.disabled = false;
                        actionRow.components.push_back(component);
                    }
                    dataPackage.addComponentRow(actionRow);
                }
                dataPackage.addMessageEmbed(messageEmbeds[newCurrentPageIndex]);
                InputEvents::respondToInputEventAsync(dataPackage).get();
            } else if (buttonIntData.at(0).buttonId == "select") {
                if (deleteAfter == true) {
                    InputEventData dataPackage03{ originalEvent };
                    InputEvents::deleteInputEventResponseAsync(dataPackage03);
                } else {
                    std::unique_ptr<InteractionData> interactionData = std::make_unique<InteractionData>(buttonIntData.at(0));
                    auto dataPackage = RespondToInputEventData{ *interactionData };
                    dataPackage.setResponseType(InputEventResponseType::Edit_Interaction_Response);
                    dataPackage.addMessageEmbed(messageEmbeds[newCurrentPageIndex]);
                    for (size_t x = 0; x < originalEvent.getMessageData().components.size(); ++x) {
                        ActionRowData actionRow{};
                        for (size_t y = 0; y < originalEvent.getMessageData().components[x].components.size(); ++y) {
                            auto component = originalEvent.getMessageData().components[x].components[y];
                            component.disabled = true;
                            actionRow.components.push_back(component);
                        }
                        dataPackage.addComponentRow(actionRow);
                    }
                    originalEvent = InputEvents::respondToInputEventAsync(dataPackage).get();
                }
                returnData.currentPageIndex = newCurrentPageIndex;
                returnData.inputEventData = originalEvent;
                returnData.buttonId = buttonIntData.at(0).buttonId;
                return returnData;
            }
        };
        return returnData;
    };
};