IMinecraftGame.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/client/game/DeferredTaskCategory.h"
#include "mc/client/game/IClientInstances.h"
#include "mc/client/game/IGameEventNotifier.h"
#include "mc/client/game/IGameServerShutdown.h"
#include "mc/client/game/IGameServerStartup.h"
#include "mc/client/game/INetworkGameConnector.h"
#include "mc/client/game/ISplitScreenChangedPublisher.h"
#include "mc/client/game/IWorldTransfer.h"
#include "mc/client/gui/GameEventNotification.h"
#include "mc/client/social/UserPlatformConnectionResult.h"
#include "mc/common/IMinecraftApp.h"
#include "mc/common/SubClientId.h"
#include "mc/deps/application/app_extensions/AppExtensionsOwner.h"
#include "mc/deps/core/file/PathBuffer.h"
#include "mc/deps/core/islands/AppIsland.h"
#include "mc/deps/core/threading/Async.h"
#include "mc/deps/core/threading/DeferredTasksManager.h"
#include "mc/deps/core/utility/AutomaticID.h"
#include "mc/deps/core/utility/EnableNonOwnerReferences.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/input/InputMode.h"
#include "mc/deps/input/PointerType.h"
#include "mc/events/NetworkType.h"
#include "mc/platform/MultiplayerLockedContext.h"
#include "mc/server/commands/test/TestAssetCommandType.h"
#include "mc/server/commands/test/TestCommandType.h"
#include "mc/sound/MusicRepeatMode.h"
 
// auto generated forward declare list
// clang-format off
class ActiveDirectoryIdentity;
class ActorAnimationControllerGroup;
class ActorAnimationGroup;
class ActorResourceDefinitionGroup;
class AppSystemRegistry;
class BlockCullingGroup;
class CDNService;
class ChunkSource;
class ClientNetworkSystem;
class ClubsService;
class ContentAcquisition;
class ContentCatalogService;
class ContentIdentity;
class ContentLogFileEndPoint;
class CubemapBackgroundResources;
class DateManager;
class DeferredLighting;
class DevConsoleLogger;
class Dimension;
class EDUSystems;
class EmoticonManager;
class EntityContext;
class ExternalContentManager;
class FlightingService;
class FontHandle;
class GameRenderer;
class GatheringManager;
class GeometryGroup;
class GlobalResourcesCrashRecovery;
class GuiData;
class IApp;
class IClientInstance;
class IContentAccessibilityProvider;
class IContentKeyProvider;
class IContentManager;
class IContentTierManager;
class IDlcValidation;
class IEntitlementManager;
class IExternalServerFile;
class IGameModuleApp;
class ILevelListCache;
class IMinecraftEventing;
class IOfferRepository;
class IResourcePackRepository;
class ISceneStack;
class ITextBoxController;
class IThirdPartyServerRepository;
class IUIDefRepository;
class IUIRepository;
class ItemRegistryRef;
class LevelDbEnv;
class LevelLoader;
class LevelSettings;
class LibraryRepository;
class LinkedAssetValidator;
class LocalPlayer;
class MarketplaceServicesManager;
class MinecraftGraphics;
class MinecraftInputHandler;
class MusicManager;
class NewPlayerSystem;
class Options;
class PackDownloadManager;
class PackManifestFactory;
class PackSourceFactory;
class ParticleEffectGroup;
class PersonaRepository;
class PersonaService;
class PixelCalc;
class Player;
class PlayerMessagingService;
class ProfanityContext;
class RealmsAPI;
class RenderControllerGroup;
class ResetCallbackObject;
class ResourceLoadManager;
class ResourcePackManager;
class SceneFactory;
class ScreenshotRecorder;
class SeasonsRenderer;
class ServerInstance;
class ServerInstanceEventCoordinator;
class ServiceDrivenImageRepository;
class ServicesManager;
class SkinRepository;
class SoundEngine;
class StoreCatalogRepository;
class SunsettingManager;
class TextToIconMapper;
class TextureAtlas;
class TreatmentPackDownloadMonitor;
class TrialManager;
class UIMeasureStrategy;
class Vec3;
class WorldTemplateManager;
struct ActorUniqueID;
struct ControllerIDtoClientMap;
struct PlayerJoinWorldContext;
struct ScreenshotOptions;
namespace Bedrock::PubSub { class Subscription; }
namespace ClientBlobCache { class Cache; }
namespace ClientBlockPipeline { class SchematicsRepository; }
namespace Core { class FilePathManager; }
namespace OreUI { class DataProviderManager_DEPRECATED; }
namespace OreUI { class IResourceAllowList; }
namespace OreUI { class Router; }
namespace Parties { class PartySystem; }
namespace Progress { class ProgressTips; }
namespace Realms { class ContentService; }
namespace Realms { class GenericRequestServiceHandler; }
namespace Realms { class RealmsServices; }
namespace Realms { class RealmsSystem; }
namespace Realms { class SubscriptionService; }
namespace Realms { struct World; }
namespace Social { class GameConnectionInfo; }
namespace Social { class IUserManager; }
namespace Social { class MultiplayerServiceManager; }
namespace Social { class PresenceManager; }
namespace Social { class SocialSystem; }
namespace Social { class User; }
namespace World { class WorldSystem; }
namespace mce { class TextureGroup; }
namespace mce { class UUID; }
// clang-format on
 
class IMinecraftGame : public ::Bedrock::EnableNonOwnerReferences,
                       public ::Bedrock::AppIsland,
                       public ::IMinecraftApp,
                       public ::IGameServerStartup,
                       public ::IGameServerShutdown,
                       public ::INetworkGameConnector,
                       public ::IClientInstances,
                       public ::IWorldTransfer,
                       public ::AppExtensions::AppExtensionsOwner,
                       public ::ISplitScreenChangedPublisher,
                       public ::IGameEventNotifier {
public:
    // virtual functions
    // NOLINTBEGIN
    virtual void initialize() = 0;
 
    virtual ~IMinecraftGame() /*override*/;
 
    virtual void update() = 0;
 
    virtual ::AppSystemRegistry& getAppSystemRegistry() = 0;
 
    virtual ::EntityContext& getEntity() const = 0;
 
    virtual void logoffAllSubclients() = 0;
 
    virtual void buildTreatmentPackStack(bool fireEvents) const = 0;
 
    virtual void queueSubclientRemoval(::SubClientId subid) = 0;
 
    virtual ::std::shared_ptr<::mce::TextureGroup> getTextureGroup() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ResourceLoadManager> getResourceLoadManager() = 0;
 
    virtual void handleReloadUIDefinitions() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IUIDefRepository> getUIDefRepo() const = 0;
 
    virtual bool canActivateKeyboard() = 0;
 
    virtual void releaseClientSubId(::SubClientId subid) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentTierManager const> getContentTierManager() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::DevConsoleLogger> getDevConsoleLogger() const = 0;
 
    virtual void setDisableInputForAllOtherClients(int id, bool disableStatus) = 0;
 
    virtual ::DeferredTasksManager<::DeferredTaskCategory>& getDeferredTasks() = 0;
 
    virtual bool shouldShowRatingsPrompt() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ServerInstanceEventCoordinator> getServerInstanceEventCoordinator() = 0;
 
    virtual bool isHostingLocalDedicatedServer() const = 0;
 
    virtual bool isLeaveGameDone() const = 0;
 
    virtual void destroyGame() = 0;
 
    virtual bool isInGame() const = 0;
 
    virtual void startLeaveGame() = 0;
 
    virtual bool isAudioInitialized() const = 0;
 
    virtual ::MusicManager const* getMusicManager() const = 0;
 
    virtual ::MusicManager* getMusicManagerNonConst() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::SoundEngine> getSoundEngine() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ITextBoxController> getTextBoxController() = 0;
 
    virtual void openPauseMenu() = 0;
 
    virtual void setIsInGame(bool isInGame) = 0;
 
    virtual void createClientItemRegistry() = 0;
 
    virtual bool hasNetworkPrivileges(bool onlyWifiAllowed) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository const>
    getThirdPartyServerRepository() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository> getThirdPartyServerRepository() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ControllerIDtoClientMap> retrieveCIDToClientMap() = 0;
 
    virtual ::std::map<::SubClientId, ::std::shared_ptr<::IClientInstance>> const& getClientInstanceMap() const = 0;
 
    virtual void joinMultiplayerWithAddress(
        ::Social::GameConnectionInfo gameConnection,
        bool                         joiningLocalServer,
        ::std::string const&         serverName,
        ::std::string const&         worldName,
        ::NetworkType                networkTypeOverride,
        ::PlayerJoinWorldContext     context
    ) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IOfferRepository> getOfferRepository() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TrialManager> getTrialManager() const = 0;
 
    virtual bool isTrialManagerInitialized() const = 0;
 
    virtual ::InputMode getCurrentInputMode() const = 0;
 
    virtual void handleInputPaneHidden() = 0;
 
    virtual bool getSuspended() const = 0;
 
    virtual bool isResuming() const = 0;
 
    virtual void setTestExecuteCommandCallback(
        ::std::function<void(::TestCommandType, ::std::vector<::std::string> const&, int)> const& callback
    ) = 0;
 
    virtual void setTestAssetCommandCallback(
        ::std::function<void(::TestAssetCommandType, ::std::vector<::std::string> const&)> const& callback
    ) = 0;
 
    virtual void runTestExecuteCommandCallback(
        ::TestCommandType                   type,
        ::std::vector<::std::string> const& tags,
        int                                 repeatCount
    ) const = 0;
 
    virtual void
    runTestAssetCommandCallback(::TestAssetCommandType type, ::std::vector<::std::string> const& tags) const = 0;
 
    virtual uint64 getClientInstanceCount() const = 0;
 
    virtual void setProfilerIsOn(bool val) = 0;
 
    virtual ::LocalPlayer* getPrimaryLocalPlayer() = 0;
 
    virtual ::LocalPlayer const* getPrimaryLocalPlayer() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::IUserManager> getUserManager() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IClientInstance> getPrimaryClientInstance() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IClientInstance const> getPrimaryClientInstance() const = 0;
 
    virtual ::ItemRegistryRef getClientItemRegistry() const = 0;
 
    virtual bool isPrimaryClientInstanceReady() const = 0;
 
    virtual void ensureAllClientsAreLeaving() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ClientNetworkSystem> getClientNetworkSystemPtr() = 0;
 
    virtual ::ClientNetworkSystem& getClientNetworkSystem() = 0;
 
    virtual ::ClientNetworkSystem const& getClientNetworkSystem() const = 0;
 
    virtual bool hasAllValidCrossPlatformSkin() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem> getNewPlayerSystem() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem const> getNewPlayerSystem() const = 0;
 
    virtual void createAndUploadWorldToRealm(
        ::std::string const&                   levelId,
        ::std::string const&                   levelName,
        ::ContentIdentity const&               premiumTemplateContentIdentity,
        ::LevelSettings const&                 settings,
        ::Realms::World                        world,
        ::std::function<void(::Realms::World)> callback
    ) = 0;
 
    virtual ::ILevelListCache& getLevelListCache() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Core::FilePathManager> getFilePathManager() = 0;
 
    virtual void setUseFontOverrides(bool useOverrides) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getFontHandle() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getUIFontHandle() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getRuneFontHandle() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getUnicodeFontHandle() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FontHandle const> getSmoothFontHandle() const = 0;
 
    virtual void onClientLevelExit(::IClientInstance& exitClient, uint exitCode) = 0;
 
    virtual bool isLocalPlayer(::ActorUniqueID const& id) const = 0;
 
    virtual ::IMinecraftEventing& getEventing() const = 0;
 
    virtual void reloadAnimationAndGeometryData(bool sync) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GeometryGroup> getGeometryGroup() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::BlockCullingGroup> getBlockCullingGroup() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ClientBlockPipeline::SchematicsRepository>
    getSchematicsRepository() const = 0;
 
    virtual ::ParticleEffectGroup& getParticleEffectGroup() const = 0;
 
    virtual ::DeferredLighting& getDeferredLighting() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::MultiplayerServiceManager> getMultiplayerServiceManager() const = 0;
 
    virtual ::IResourcePackRepository& getResourcePackRepository() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentKeyProvider const> getKeyProvider() const = 0;
 
    virtual ::ResourcePackManager& getResourcePackManager() const = 0;
 
    virtual ::ResourcePackManager& getServerResourcePackManager() = 0;
 
    virtual ::PackManifestFactory& getPackManifestFactory() = 0;
 
    virtual ::PlayerMessagingService& getPlayerMessagingService() = 0;
 
    virtual ::std::shared_ptr<::SkinRepository> getSkinRepository() const = 0;
 
    virtual ::PersonaRepository& getPersonaRepository() const = 0;
 
    virtual ::MarketplaceServicesManager& getMarketplaceServicesManager() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::mce::TextureGroup> getStoreCacheTextures() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::MinecraftGraphics> getMinecraftGraphics() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IUIRepository> getUIRepository() const = 0;
 
    virtual bool isPrimaryLevelCrossPlatformMultiplayer() const = 0;
 
    virtual bool isPrimaryLevelMultiplayer() const = 0;
 
    virtual ::std::string getMultiplayerDisabledTextTitle(::MultiplayerLockedContext context) const = 0;
 
    virtual ::std::string getMultiplayerDisabledTextBody(::MultiplayerLockedContext context) const = 0;
 
    virtual void setRenderingSize(int w, int h) = 0;
 
    virtual void recalculateScene() = 0;
 
    virtual void setUISizeAndScale(int w, int h, float forcedGuiScale) = 0;
 
    virtual bool isReadyToRender() const = 0;
 
    virtual void onDimensionChanged() = 0;
 
    virtual void setLeaveGameInProgressAsReadyToContinue() = 0;
 
    virtual void onClientCreatedLevel(::IClientInstance& client) = 0;
 
    virtual uint64 generateClientId(
        bool                              forceReset,
        bool&                             generatedNewId,
        uint64                            clientIdModifier,
        ::std::shared_ptr<::Social::User> user
    ) = 0;
 
    virtual ::std::weak_ptr<::RealmsAPI> getRealms() = 0;
 
    virtual ::Realms::ContentService& getRealmsContentService() = 0;
 
    virtual bool getMouseGrabbed() const = 0;
 
    virtual void navigateToPlayScreenFriendsTab() = 0;
 
    virtual bool isInServer() const = 0;
 
    virtual bool isInRealm() const = 0;
 
    virtual bool isShowingLoadingScreen() const = 0;
 
    virtual bool isRenderingLoadingScreen() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::StoreCatalogRepository> getStoreCatalog() const = 0;
 
    virtual ::ServiceDrivenImageRepository& getServiceImageRepository() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LibraryRepository> getLibraryRepository() const = 0;
 
    virtual ::GameRenderer& getGameRenderer() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TextureAtlas> getTextureAtlas() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TextureAtlas> getItemTextureAtlas() = 0;
 
    virtual bool hasActorResourceDefinitionGroup() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup const>
    getActorResourceDefinitionGroup() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup> getActorResourceDefinitionGroupMutable() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup const> getRenderControllerGroup() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup> getRenderControllerGroup() = 0;
 
    virtual int getMaxPlayerCount() const = 0;
 
    virtual ::Bedrock::Threading::Async<::Core::PathBuffer<::std::string>>
    requestScreenshot(::ScreenshotOptions& screenshotOptions) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::OreUI::IResourceAllowList> getOreUIResourceAllowList() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::DateManager> getDateManager() const = 0;
 
    virtual ::PixelCalc const& getDpadScale() const = 0;
 
    virtual void setKeyboardForcedHeight(float height, bool isShowSignal) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ISceneStack const> getMainSceneStack() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ISceneStack> getMainSceneStack() = 0;
 
    virtual ::OreUI::Router& getUIRouter() = 0;
 
    virtual ::OreUI::DataProviderManager_DEPRECATED& getDataProviderManager() = 0;
 
    virtual uint getUIRenderClientMask() const = 0;
 
    virtual bool useMinecraftVersionOfXBLUI() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PersonaService> getPersonaService() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GatheringManager> getGatheringManager() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::CDNService> getCDNService() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ContentCatalogService> getContentCatalogService() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FlightingService> getFlightingService() const = 0;
 
    virtual ::std::shared_ptr<::FlightingService> getFlightingServicePtr() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TreatmentPackDownloadMonitor const>
    getTreatmentPackDownloadMonitor() const = 0;
 
    virtual ::SceneFactory& getPrimarySceneFactory() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::MinecraftInputHandler> getInput() const = 0;
 
    virtual void grabMouse() = 0;
 
    virtual void releaseMouse() = 0;
 
    virtual void refocusMouse(bool lostMouse) = 0;
 
    virtual void setMouseType(::Bedrock::Input::PointerType type) = 0;
 
    virtual void play(::std::string const& name, ::Vec3 const& pos, float volume, float pitch) = 0;
 
    virtual void playUI(::std::string const& name, float volume, float pitch) = 0;
 
    virtual void fadeOutMusic() = 0;
 
    virtual void onPlayerLoaded(::IClientInstance& client, ::Player& player) = 0;
 
    virtual bool checkForPiracy() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::CubemapBackgroundResources> getCubemapBackgroundResources() = 0;
 
    virtual void setAppWillTerminate(bool willTerminate) = 0;
 
    virtual ::ServerInstance* getServerInstance() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ServerInstance> getServerInstanceNonOwnPtr() = 0;
 
    virtual void setLaunchedFromLegacyVersion(bool launchedFromLegacyVersion) = 0;
 
    virtual ::UIMeasureStrategy& getUIMeasureStrategy() = 0;
 
    virtual void registerUpsellScreen() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::WorldTemplateManager> getWorldTemplateManager() const = 0;
 
    virtual ::World::WorldSystem& getWorldSystem() const = 0;
 
    virtual bool isWorldSystemReady() const = 0;
 
    virtual ::Social::SocialSystem& getSocialSystem() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::Parties::PartySystem> getPartySystem() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Progress::ProgressTips> getUIProgressTips() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsSystem> getRealmsSystem() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IEntitlementManager> getEntitlementManager() = 0;
 
    virtual ::IDlcValidation& getDlcValidation() = 0;
 
    virtual ::ServicesManager& getServicesManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::SunsettingManager> getSunsettingManager() = 0;
 
    virtual void pauseContentDownloads() = 0;
 
    virtual void resumeContentDownloads() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IExternalServerFile> getExternalServer() const = 0;
 
    virtual bool isStartingGame() const = 0;
 
    virtual bool isSplitscreenJoinEnabled() const = 0;
 
    virtual bool canAddSplitscreenSubClient(int controllerId) const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelLoader> getLevelLoader() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ExternalContentManager> getContentManager() = 0;
 
    virtual ::std::shared_ptr<::IClientInstance>
    tryGetClientInstanceFromPlayerUUID(::mce::UUID const& playerId) const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider const> getAccessibilityProvider() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider> getAccessibilityProvider() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ContentAcquisition> getContentAcquisition() const = 0;
 
    virtual void onGameEventNotification(::ui::GameEventNotification notification) = 0;
 
    virtual void setRealmsLoadingLink(bool state) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IApp> getApp() = 0;
 
    virtual void clearCache() = 0;
 
    virtual ::IContentManager& getResourceContentManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::EmoticonManager const> getEmoticonManager() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper const> getTextToIconMapper() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper> getTextToIconMapper() = 0;
 
    virtual void onPrimaryUserReconnect(::Social::UserPlatformConnectionResult status, bool isUserInitiated) = 0;
 
    virtual void setSmoothFontStyle() = 0;
 
    virtual void setUIFontStyle() = 0;
 
    virtual void copyInternalSettingsFolderToExternalLocation() const = 0;
 
    virtual void joinRealmFromInvite(::Realms::World const& world) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsServices> getRealmsServices() = 0;
 
    virtual ::std::weak_ptr<::ClubsService> getClubsService() = 0;
 
    virtual ::std::shared_ptr<::Realms::GenericRequestServiceHandler> getGenericRealmsService() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::SubscriptionService> getRealmsSubscriptionService() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActiveDirectoryIdentity> getActiveDirectoryIdentity() = 0;
 
    virtual ::PackSourceFactory& getPackSourceFactory() const = 0;
 
    virtual void displayActiveDirectoryLoginDialog() = 0;
 
    virtual void resetInput() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::PresenceManager> getPresenceManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GuiData> getPrimaryGuiData() = 0;
 
    virtual bool isPrimaryUserSigninInProgress() const = 0;
 
    virtual void setupCommandParser(::IClientInstance& client) = 0;
 
    virtual void stopSound(::std::string const& name) = 0;
 
    virtual void stopSounds() = 0;
 
    virtual ::PackDownloadManager& getPackDownloadManager() = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> getLinkedAssetValidator() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> getLinkedAssetValidator() = 0;
 
    virtual void addSubClientInstanceAndAssociateToUser(int controllerId) = 0;
 
    virtual void forEachClientInstance(::std::function<void(::IClientInstance&)> callback) = 0;
 
    virtual bool isInitialized() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::SeasonsRenderer> getSeasonsRenderer() = 0;
 
    virtual ::std::shared_ptr<::ActorAnimationGroup> getActorAnimationGroup() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorAnimationControllerGroup> getActorAnimationControllerGroup() const = 0;
 
    virtual bool isMultiplayerServiceManagerReady() const = 0;
 
    virtual void doPrimaryClientReadyWork(::std::function<void()> workFn) = 0;
 
    virtual void doUserManagerReadyWork(::std::function<void()> workFn) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ScreenshotRecorder> getScreenshotRecorder() = 0;
 
    virtual ::std::shared_ptr<::ClientBlobCache::Cache> getClientBlobCache() = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::ContentLogFileEndPoint> const getContentFileLogEndPoint() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::EDUSystems const> getEDUSystems() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::EDUSystems> getEDUSystems() = 0;
 
    virtual ::std::shared_ptr<::Options> getPrimaryUserOptions() = 0;
 
    virtual ::std::shared_ptr<::Options const> getPrimaryUserOptions() const = 0;
 
    virtual void tryShowXblFirstLaunchScreen(bool isUserConnectedToPlatform) = 0;
 
    virtual ::Bedrock::PubSub::Subscription
    registerSplitScreenChangedListener(::std::function<void(uchar)> callback) const = 0;
 
    virtual uchar getSplitScreenCount() const = 0;
 
    virtual ::IGameModuleApp& getGameModule() = 0;
 
    virtual ::std::shared_ptr<void*> requestMusicDeferment() = 0;
 
    virtual bool isMusicEnabled() const = 0;
 
    virtual void queueCustomMusic(
        ::std::string const& eventName,
        float                volume,
        float                fadeoutSeconds,
        ::MusicRepeatMode    playMode
    ) = 0;
 
    virtual void
    playCustomMusic(::std::string const& eventName, float volume, float fadeoutSeconds, ::MusicRepeatMode playMode) = 0;
 
    virtual void stopCustomMusic(float fadeoutSeconds) = 0;
 
    virtual void setMusicCommandVolumeMultiplier(float volumeMultiplier) = 0;
 
    virtual float calculateScreenSizeToResolutionScalar(int const width, int const height) const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GlobalResourcesCrashRecovery const>
    GetGlobalResourcesCrashRecovery() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelDbEnv> getLevelDbEnv() = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::ChunkSource> getClientGenChunkSource(::DimensionType const& dimensionType) = 0;
 
    virtual bool isEditorModeEnabled() const = 0;
 
    virtual void setResetCallbackObject(::ResetCallbackObject* obj) = 0;
 
    virtual void resetThreadCallbacks() = 0;
 
    virtual void shutdownServer() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ProfanityContext> getProfanityContext() = 0;
 
    virtual double getGameUpdateDurationInSeconds() const = 0;
 
    virtual ::std::tuple<bool, int> GetEcoModeSettings() const = 0;
    // NOLINTEND
 
public:
    // destructor thunk
    // NOLINTBEGIN
    MCNAPI void $dtor();
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
 
    // NOLINTEND
 
public:
    // vftables
    // NOLINTBEGIN
    MCNAPI static void** $vftableForIMinecraftApp();
 
    MCNAPI static void** $vftableForINetworkGameConnector();
 
    MCNAPI static void** $vftableForIClientInstances();
 
    MCNAPI static void** $vftableForAppIsland();
 
    MCNAPI static void** $vftableForIGameServerStartup();
 
    MCNAPI static void** $vftableForISplitScreenChangedPublisher();
 
    MCNAPI static void** $vftableForAppExtensionsOwner();
 
    MCNAPI static void** $vftableForIGameEventNotifier();
 
    MCNAPI static void** $vftableForEnableNonOwnerReferences();
 
    MCNAPI static void** $vftableForIWorldTransfer();
 
    MCNAPI static void** $vftableForIGameServerShutdown();
    // NOLINTEND
};