MinecraftGame.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/certificates/identity/edu/CredentialsObserver.h"
#include "mc/certificates/identity/edu/GenericCredentialsEvent.h"
#include "mc/client/events/OnlineSafetyDialogVisibility.h"
#include "mc/client/game/DeferredTaskCategory.h"
#include "mc/client/game/IMinecraftGame.h"
#include "mc/client/game/IMultiPlayerServices.h"
#include "mc/client/game/SerialWorkList.h"
#include "mc/client/game/StartIntent.h"
#include "mc/client/game/local_server_launcher/ILocalServerLauncherImpl.h"
#include "mc/client/gui/GameEventNotification.h"
#include "mc/client/options/OptionsObserver.h"
#include "mc/client/renderer/texture/TextureAtlasStatus.h"
#include "mc/client/services/layout/ILayoutServiceProvider.h"
#include "mc/client/social/JoinGameStatus.h"
#include "mc/client/social/MultiplayerServiceIdentifier.h"
#include "mc/client/social/UserPlatformConnectionResult.h"
#include "mc/common/App.h"
#include "mc/common/SubClientId.h"
#include "mc/deps/application/LowMemorySeverity.h"
#include "mc/deps/core/file/PathBuffer.h"
#include "mc/deps/core/platform/OperationMode.h"
#include "mc/deps/core/threading/Async.h"
#include "mc/deps/core/threading/DeferredTasksManager.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/input/InputMode.h"
#include "mc/deps/input/PointerType.h"
#include "mc/events/IMinecraftEventing.h"
#include "mc/events/NetworkType.h"
#include "mc/locale/I18nObserver.h"
#include "mc/network/TransportLayer.h"
#include "mc/platform/MultiplayerLockedContext.h"
#include "mc/platform/brstd/move_only_function.h"
#include "mc/resources/ResourcePackListener.h"
#include "mc/sound/MusicRepeatMode.h"
#include "mc/world/level/LevelListener.h"
 
// auto generated forward declare list
// clang-format off
class ActiveDirectoryIdentity;
class ActorAnimationControllerGroup;
class ActorAnimationGroup;
class ActorResourceDefinitionGroup;
class AppSystemRegistry;
class BlockCullingGroup;
class ChunkSource;
class ClientInstance;
class ClientNetworkSystem;
class ClubsService;
class ContentAcquisition;
class ContentCatalogService;
class ContentIdentity;
class ContentLogFileEndPoint;
class CubemapBackgroundResources;
class DateManager;
class DeferredLighting;
class DevConsoleLogger;
class EDUSystems;
class EmoticonManager;
class EntityContext;
class ExternalContentManager;
class FileArchiver;
class FlightingService;
class FontRepository;
class GameModuleClient;
class GameRenderer;
class GatheringManager;
class GeometryGroup;
class GlobalResourcesCrashRecovery;
class GuiData;
class IApp;
class IClientDimensionExtensions;
class IClientInstance;
class IContentAccessibilityProvider;
class IContentKeyProvider;
class IContentManager;
class IContentTierManager;
class IDlcValidation;
class IEntitlementManager;
class IExternalServerFile;
class IGameModuleApp;
class IGameModuleShared;
class ILayoutServiceCache;
class ILevelListCache;
class IMinecraftEventing;
class IOfferRepository;
class IResourcePackRepository;
class ISceneStack;
class ITextBoxController;
class IThirdPartyServerRepository;
class IUIDefRepository;
class IUIRepository;
class ItemRegistryRef;
class LatencyGraphDisplay;
class LayoutRefreshEventSource;
class LayoutService;
class LevelDbEnv;
class LevelLoader;
class LevelSettings;
class LibraryRepository;
class LinkedAssetValidator;
class LocalPlayer;
class MarketplaceServicesManager;
class Minecraft;
class MinecraftGraphics;
class MinecraftInputHandler;
class MusicManager;
class NewPlayerSystem;
class Option;
class OptionRegistry;
class PackDownloadManager;
class PackManifest;
class PackManifestFactory;
class PackSourceFactory;
class ParticleEffectGroup;
class PersonaRepository;
class PersonaService;
class PixelCalc;
class Player;
class PlayerMessagingService;
class ProfanityContext;
class PushNotificationMessage;
class RealmsAPI;
class RenderControllerGroup;
class ResetCallbackObject;
class ResourceLoadManager;
class ResourcePackManager;
class ResourcePackStack;
class SceneFactory;
class ScreenshotRecorder;
class SeasonsRenderer;
class SerialWorkList;
class ServerInstance;
class ServerInstanceEventCoordinator;
class ServerNetworkHandler;
class ServiceDrivenImageRepository;
class ServicesManager;
class SkinRepository;
class SoundEngine;
class StoreCatalogRepository;
class SunsettingManager;
class TaskGroup;
class TextToIconMapper;
class TextureAtlas;
class Timer;
class TreatmentPackDownloadMonitor;
class TrialManager;
class UIMeasureStrategy;
class Vec3;
class WorldTemplateManager;
class WorldTransferAgent;
struct ActorUniqueID;
struct ControllerIDtoClientMap;
struct DimensionType;
struct ExperienceJoinRequestInfo;
struct ExternalWorldTransferActionFunc;
struct GameConnectionInfoEx;
struct LocalWorldTransferActionFunc;
struct MinecraftGameArguments;
struct PlayerJoinWorldContext;
struct RealmTransferActionFunc;
struct ScreenshotOptions;
namespace Automation { class AutomationClient; }
namespace Bedrock { class ActivationArguments; }
namespace Bedrock::Profiling { class ProfilingOrchestrator; }
namespace Bedrock::PubSub { class Subscription; }
namespace ClientBlockPipeline { class SchematicsRepository; }
namespace Core { class FilePathManager; }
namespace LocalServerLauncher { class IGameInterface; }
namespace LocalServerLauncher { class IServerInstanceBuilder; }
namespace LocalServerLauncher { struct GameDependencies; }
namespace LocalServerLauncher { struct ServerInitData; }
namespace LocalServerLauncher { struct ServerLaunchResult; }
namespace LocalServerLauncher::Impl { struct AllDependencies; }
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 RealmId; }
namespace Realms { struct World; }
namespace Social { class GameConnectionInfo; }
namespace Social { class IUserManager; }
namespace Social { class MultiplayerGameInfo; }
namespace Social { class MultiplayerServiceManager; }
namespace Social { class PresenceManager; }
namespace Social { class SocialSystem; }
namespace Social { class User; }
namespace World { class WorldSystem; }
namespace dragon::framerenderer { struct DebugParameters; }
namespace edu::auth { struct CredentialsAcquired; }
namespace edu::auth { struct CredentialsRefreshSuccess; }
namespace edu::auth { struct CredsLost; }
namespace mce { class TextureGroup; }
namespace mce { class UUID; }
// clang-format on
 
class MinecraftGame : public ::IMinecraftGame,
                      public ::ILayoutServiceProvider,
                      public ::App,
                      public ::LevelListener,
                      public ::ResourcePackListener,
                      public ::OptionsObserver,
                      public ::edu::auth::CredentialsObserver,
                      public ::I18nObserver,
                      public ::IMultiPlayerServices,
                      public ::LocalServerLauncher::ILocalServerLauncherImpl {
public:
    // MinecraftGame inner types declare
    // clang-format off
    class ClientInterface;
    struct InitContext;
    struct FrameGapImpl;
    // clang-format on
 
    // MinecraftGame inner types define
    enum class SuspendState : int {
        Suspending = 0,
        Suspended  = 1,
        Resuming   = 2,
        Running    = 3,
    };
 
    enum class DeviceLostState : int {
        Valid      = 0,
        Lost       = 1,
        Recovering = 2,
    };
 
    enum class SurfaceState : int {
        Valid = 0,
        Lost  = 1,
    };
 
    enum class WorkList : uint64 {
        AppInitialize = 0,
        AppResume     = 1,
        AppDeviceLost = 2,
        Count         = 3,
    };
 
    class ClientInterface {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::UntypedStorage<8, 8>  mUnk4882be;
        ::ll::UntypedStorage<8, 16> mUnkf28199;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        ClientInterface& operator=(ClientInterface const&);
        ClientInterface(ClientInterface const&);
        ClientInterface();
 
    public:
        // member functions
        // NOLINTBEGIN
        MCNAPI ::MinecraftGame::ClientInterface&
        operator=(::gsl::not_null<::std::shared_ptr<::ClientInstance>> clientInstance);
        // NOLINTEND
    };
 
    struct InitContext {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::UntypedStorage<8, 32> mUnka8b3b6;
        ::ll::UntypedStorage<8, 16> mUnkc9621b;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        InitContext& operator=(InitContext const&);
        InitContext(InitContext const&);
        InitContext();
    };
 
    struct FrameGapImpl {
    public:
        // member variables
        // NOLINTBEGIN
        ::ll::UntypedStorage<8, 8> mUnk2970b7;
        // NOLINTEND
 
    public:
        // prevent constructor by default
        FrameGapImpl& operator=(FrameGapImpl const&);
        FrameGapImpl(FrameGapImpl const&);
        FrameGapImpl();
    };
 
public:
    // member variables
    // NOLINTBEGIN
    ::ll::UntypedStorage<8, 16>   mUnk31cb40;
    ::ll::UntypedStorage<8, 64>   mUnk26362f;
    ::ll::UntypedStorage<8, 8>    mUnk5833c3;
    ::ll::UntypedStorage<8, 8>    mUnk707e20;
    ::ll::UntypedStorage<8, 8>    mUnk77bae9;
    ::ll::UntypedStorage<8, 8>    mUnk39dbf1;
    ::ll::UntypedStorage<8, 8>    mUnkb9a1e2;
    ::ll::UntypedStorage<8, 8>    mUnka617fc;
    ::ll::UntypedStorage<8, 8>    mUnk847dc8;
    ::ll::UntypedStorage<8, 8>    mUnk1a8ba7;
    ::ll::UntypedStorage<8, 8>    mUnk8c1a51;
    ::ll::UntypedStorage<8, 8>    mUnkdcd0a8;
    ::ll::UntypedStorage<8, 8>    mUnk27a9f1;
    ::ll::UntypedStorage<8, 8>    mUnk6449d7;
    ::ll::UntypedStorage<8, 8>    mUnk18dd91;
    ::ll::UntypedStorage<8, 8>    mUnke812cf;
    ::ll::UntypedStorage<8, 8>    mUnk102e50;
    ::ll::UntypedStorage<8, 8>    mUnkd0fa73;
    ::ll::UntypedStorage<8, 8>    mUnk30cf6e;
    ::ll::UntypedStorage<8, 8>    mUnkf2bb2d;
    ::ll::UntypedStorage<1, 1>    mUnk73dd14;
    ::ll::UntypedStorage<1, 1>    mUnk8622d0;
    ::ll::UntypedStorage<8, 16>   mUnke052b6;
    ::ll::UntypedStorage<8, 8>    mUnk79ddba;
    ::ll::UntypedStorage<8, 8>    mUnkf926be;
    ::ll::UntypedStorage<8, 8>    mUnk37afa1;
    ::ll::UntypedStorage<8, 8>    mUnk68dc1e;
    ::ll::UntypedStorage<8, 16>   mUnka2869f;
    ::ll::UntypedStorage<8, 8>    mUnkde38fc;
    ::ll::UntypedStorage<8, 8>    mUnk9a183a;
    ::ll::UntypedStorage<8, 8>    mUnk46def3;
    ::ll::UntypedStorage<8, 8>    mUnkc587de;
    ::ll::UntypedStorage<8, 8>    mUnk4a17b1;
    ::ll::UntypedStorage<8, 8>    mUnk812bde;
    ::ll::UntypedStorage<8, 32>   mUnkb501e6;
    ::ll::UntypedStorage<8, 8>    mUnk8f8079;
    ::ll::UntypedStorage<8, 8>    mUnkcd6826;
    ::ll::UntypedStorage<8, 16>   mUnk5849e3;
    ::ll::UntypedStorage<8, 16>   mUnk336443;
    ::ll::UntypedStorage<1, 1>    mUnkb6d61e;
    ::ll::UntypedStorage<8, 16>   mUnkd61d74;
    ::ll::UntypedStorage<4, 4>    mUnkda7647;
    ::ll::UntypedStorage<4, 4>    mUnk730c95;
    ::ll::UntypedStorage<1, 1>    mUnk391e21;
    ::ll::UntypedStorage<4, 4>    mUnk859534;
    ::ll::UntypedStorage<8, 8>    mUnk8b857f;
    ::ll::UntypedStorage<8, 8>    mUnkeb3d6b;
    ::ll::UntypedStorage<8, 16>   mUnk8598e2;
    ::ll::UntypedStorage<8, 32>   mUnk29d8a4;
    ::ll::UntypedStorage<8, 16>   mUnk8120e2;
    ::ll::UntypedStorage<1, 1>    mUnkbf9e1f;
    ::ll::UntypedStorage<1, 1>    mUnkf1c360;
    ::ll::UntypedStorage<8, 8>    mUnkcc0494;
    ::ll::UntypedStorage<8, 8>    mUnkc32677;
    ::ll::UntypedStorage<8, 8>    mUnkfb38cb;
    ::ll::UntypedStorage<1, 1>    mUnk2d6ae9;
    ::ll::UntypedStorage<1, 1>    mUnk549470;
    ::ll::UntypedStorage<4, 4>    mUnkdaeaa4;
    ::ll::UntypedStorage<4, 4>    mUnk978a98;
    ::ll::UntypedStorage<1, 1>    mUnk7186c4;
    ::ll::UntypedStorage<1, 1>    mUnkeeb15c;
    ::ll::UntypedStorage<1, 1>    mUnk21487c;
    ::ll::UntypedStorage<1, 1>    mUnk7f0094;
    ::ll::UntypedStorage<1, 1>    mUnk1f7e9d;
    ::ll::UntypedStorage<1, 1>    mUnk71b5c7;
    ::ll::UntypedStorage<8, 32>   mUnk570845;
    ::ll::UntypedStorage<4, 4>    mUnk785de7;
    ::ll::UntypedStorage<8, 416>  mUnke04be5;
    ::ll::UntypedStorage<1, 1>    mUnk19eccc;
    ::ll::UntypedStorage<4, 4>    mUnk97e7f8;
    ::ll::UntypedStorage<8, 16>   mUnk61cb9f;
    ::ll::UntypedStorage<1, 1>    mUnk3ebcf8;
    ::ll::UntypedStorage<1, 1>    mUnk39e2bc;
    ::ll::UntypedStorage<1, 1>    mUnked6187;
    ::ll::UntypedStorage<1, 1>    mUnk9e21e6;
    ::ll::UntypedStorage<1, 1>    mUnkfed6cd;
    ::ll::UntypedStorage<1, 1>    mUnk41cbb8;
    ::ll::UntypedStorage<4, 4>    mUnk9b7c5f;
    ::ll::UntypedStorage<1, 1>    mUnkc8c391;
    ::ll::UntypedStorage<1, 1>    mUnka7b938;
    ::ll::UntypedStorage<1, 1>    mUnk5907ad;
    ::ll::UntypedStorage<1, 1>    mUnk6f26ef;
    ::ll::UntypedStorage<8, 16>   mUnkedce32;
    ::ll::UntypedStorage<8, 56>   mUnk2fd9a7;
    ::ll::UntypedStorage<8, 8>    mUnke44711;
    ::ll::UntypedStorage<8, 80>   mUnk27b53a;
    ::ll::UntypedStorage<8, 8>    mUnk3ee8f3;
    ::ll::UntypedStorage<8, 16>   mUnk5d44d0;
    ::ll::UntypedStorage<1, 1>    mUnk64a982;
    ::ll::UntypedStorage<1, 1>    mUnk456e9b;
    ::ll::UntypedStorage<1, 1>    mUnkd57772;
    ::ll::UntypedStorage<1, 1>    mUnk780cef;
    ::ll::UntypedStorage<8, 8>    mUnkbbeca7;
    ::ll::UntypedStorage<8, 8>    mUnk523cee;
    ::ll::UntypedStorage<8, 40>   mUnka60eca;
    ::ll::UntypedStorage<8, 32>   mUnk78c4dd;
    ::ll::UntypedStorage<1, 1>    mUnka2f794;
    ::ll::UntypedStorage<1, 1>    mUnk90b4e5;
    ::ll::UntypedStorage<8, 16>   mUnk3fa9bf;
    ::ll::UntypedStorage<8, 8>    mUnkfa9b14;
    ::ll::UntypedStorage<8, 8>    mUnk975fa0;
    ::ll::UntypedStorage<8, 8>    mUnkc95a9f;
    ::ll::UntypedStorage<8, 16>   mUnk44f519;
    ::ll::UntypedStorage<8, 8>    mUnka426aa;
    ::ll::UntypedStorage<8, 16>   mUnkd412af;
    ::ll::UntypedStorage<8, 16>   mUnk333c36;
    ::ll::UntypedStorage<8, 8>    mUnkab5b49;
    ::ll::UntypedStorage<8, 8>    mUnk2d070e;
    ::ll::UntypedStorage<8, 8>    mUnkffc4a2;
    ::ll::UntypedStorage<8, 8>    mUnk87a54d;
    ::ll::UntypedStorage<8, 8>    mUnk80cd0e;
    ::ll::UntypedStorage<8, 8>    mUnk692520;
    ::ll::UntypedStorage<8, 8>    mUnkb8db74;
    ::ll::UntypedStorage<8, 16>   mUnkb87b62;
    ::ll::UntypedStorage<8, 8>    mUnkb69251;
    ::ll::UntypedStorage<8, 8>    mUnk138dbc;
    ::ll::UntypedStorage<8, 8>    mUnk125782;
    ::ll::UntypedStorage<8, 8>    mUnk6585d8;
    ::ll::UntypedStorage<8, 8>    mUnk116bf2;
    ::ll::UntypedStorage<8, 8>    mUnkf25a9b;
    ::ll::UntypedStorage<8, 8>    mUnk75183c;
    ::ll::UntypedStorage<8, 8>    mUnk984c5b;
    ::ll::UntypedStorage<8, 16>   mUnk795ad2;
    ::ll::UntypedStorage<8, 8>    mUnkd9da77;
    ::ll::UntypedStorage<8, 16>   mUnkcc1ee6;
    ::ll::UntypedStorage<8, 8>    mUnk291774;
    ::ll::UntypedStorage<8, 8>    mUnk8f0421;
    ::ll::UntypedStorage<8, 16>   mUnk9ac038;
    ::ll::UntypedStorage<8, 64>   mUnk33501c;
    ::ll::UntypedStorage<8, 8>    mUnk95a9d2;
    ::ll::UntypedStorage<8, 8>    mUnk78243e;
    ::ll::UntypedStorage<8, 8>    mUnkb0966b;
    ::ll::UntypedStorage<8, 8>    mUnke4850d;
    ::ll::UntypedStorage<8, 8>    mUnk949250;
    ::ll::UntypedStorage<8, 8>    mUnk94c9dc;
    ::ll::UntypedStorage<8, 8>    mUnk56924c;
    ::ll::UntypedStorage<8, 8>    mUnk7c70a9;
    ::ll::UntypedStorage<8, 8>    mUnka6f4b7;
    ::ll::UntypedStorage<8, 8>    mUnk4c8c20;
    ::ll::UntypedStorage<8, 16>   mUnkde6f9f;
    ::ll::UntypedStorage<8, 16>   mUnk51caaa;
    ::ll::UntypedStorage<8, 16>   mUnk88dd50;
    ::ll::UntypedStorage<8, 8>    mUnkf13f9f;
    ::ll::UntypedStorage<8, 8>    mUnk46f031;
    ::ll::UntypedStorage<8, 8>    mUnkad7e31;
    ::ll::UntypedStorage<8, 8>    mUnk41ce20;
    ::ll::UntypedStorage<8, 8>    mUnk5cf030;
    ::ll::UntypedStorage<8, 8>    mUnkb9503e;
    ::ll::UntypedStorage<8, 8>    mUnk9c023b;
    ::ll::UntypedStorage<8, 8>    mUnk5315ca;
    ::ll::UntypedStorage<8, 8>    mUnk276668;
    ::ll::UntypedStorage<8, 8>    mUnk3ec43f;
    ::ll::UntypedStorage<8, 8>    mUnkb5e444;
    ::ll::UntypedStorage<8, 16>   mUnk36c9d2;
    ::ll::UntypedStorage<8, 8>    mUnk91e453;
    ::ll::UntypedStorage<8, 8>    mUnk56d657;
    ::ll::UntypedStorage<8, 8>    mUnkc1e9f3;
    ::ll::UntypedStorage<8, 48>   mUnka02940;
    ::ll::UntypedStorage<8, 16>   mUnk748223;
    ::ll::UntypedStorage<8, 16>   mUnkec6beb;
    ::ll::UntypedStorage<8, 8>    mUnk55dcf8;
    ::ll::UntypedStorage<8, 8>    mUnk585275;
    ::ll::UntypedStorage<8, 16>   mUnk5f5935;
    ::ll::UntypedStorage<8, 8>    mUnkd12853;
    ::ll::UntypedStorage<8, 8>    mUnk44d437;
    ::ll::UntypedStorage<8, 8>    mUnk98cc86;
    ::ll::UntypedStorage<8, 8>    mUnk6725e8;
    ::ll::UntypedStorage<8, 16>   mUnk7417c6;
    ::ll::UntypedStorage<8, 8>    mUnkd72bcd;
    ::ll::UntypedStorage<8, 8>    mUnk6c5fec;
    ::ll::UntypedStorage<8, 16>   mUnk2b5c1a;
    ::ll::UntypedStorage<8, 16>   mUnkdaad93;
    ::ll::UntypedStorage<8, 8>    mUnk2a83b2;
    ::ll::UntypedStorage<8, 8>    mUnkd10826;
    ::ll::UntypedStorage<8, 8>    mUnk64ddee;
    ::ll::UntypedStorage<8, 64>   mUnkd24a7a;
    ::ll::UntypedStorage<8, 8>    mUnkec79fd;
    ::ll::UntypedStorage<8, 1072> mUnk187d9e;
    ::ll::UntypedStorage<8, 8>    mUnk74222f;
    ::ll::UntypedStorage<8, 8>    mUnk468478;
    ::ll::UntypedStorage<8, 8>    mUnkea13b7;
    ::ll::UntypedStorage<8, 936>  mUnk9947a0;
    ::ll::UntypedStorage<8, 16>   mUnkbf42d0;
    ::ll::UntypedStorage<8, 16>   mUnk469d3c;
    ::ll::UntypedStorage<8, 8>    mUnkf245c7;
    ::ll::UntypedStorage<8, 64>   mUnk30b039;
    ::ll::UntypedStorage<8, 8>    mUnk6906a6;
    ::ll::UntypedStorage<8, 8>    mUnka198d7;
    ::ll::UntypedStorage<8, 64>   mUnk63da8b;
    ::ll::UntypedStorage<8, 8>    mUnk68bd55;
    ::ll::UntypedStorage<8, 8>    mUnkd56e6e;
    ::ll::UntypedStorage<8, 64>   mUnk6331f9;
    ::ll::UntypedStorage<8, 64>   mUnkfb3c1e;
    ::ll::UntypedStorage<8, 16>   mUnkc74988;
    ::ll::UntypedStorage<8, 8>    mUnk4764de;
    ::ll::UntypedStorage<8, 8>    mUnk2db41b;
    ::ll::UntypedStorage<8, 64>   mUnk4282e8;
    ::ll::UntypedStorage<8, 8>    mUnk313b8d;
    ::ll::UntypedStorage<8, 16>   mUnka4d1d6;
    ::ll::UntypedStorage<8, 16>   mUnk4a4bbd;
    ::ll::UntypedStorage<8, 8>    mUnkb98e22;
    ::ll::UntypedStorage<8, 64>   mUnk358786;
    ::ll::UntypedStorage<8, 8>    mUnk633776;
    ::ll::UntypedStorage<8, 8>    mUnkc61c3a;
    ::ll::UntypedStorage<8, 8>    mUnk910337;
    ::ll::UntypedStorage<8, 8>    mUnkd6ff96;
    ::ll::UntypedStorage<8, 8>    mUnk51e772;
    ::ll::UntypedStorage<8, 8>    mUnkf2c3d8;
    ::ll::UntypedStorage<8, 64>   mUnkc5fc6f;
    ::ll::UntypedStorage<8, 8>    mUnk7e94f8;
    ::ll::UntypedStorage<8, 8>    mUnkf60a71;
    ::ll::UntypedStorage<8, 16>   mUnk9f4932;
    ::ll::UntypedStorage<8, 8>    mUnk93ccfd;
    ::ll::UntypedStorage<1, 1>    mUnk4d836f;
    ::ll::UntypedStorage<8, 16>   mUnk626810;
    ::ll::UntypedStorage<8, 8>    mUnkce7b8c;
    ::ll::UntypedStorage<8, 8>    mUnka05418;
    ::ll::UntypedStorage<8, 16>   mUnkfb7cce;
    ::ll::UntypedStorage<8, 8>    mUnk17a5e5;
    ::ll::UntypedStorage<8, 8>    mUnk1d082c;
    ::ll::UntypedStorage<8, 8>    mUnk721c07;
    ::ll::UntypedStorage<8, 8>    mUnk75c011;
    ::ll::UntypedStorage<8, 8>    mUnk662066;
    ::ll::UntypedStorage<8, 8>    mUnka63939;
    ::ll::UntypedStorage<8, 8>    mUnkd68cd6;
    ::ll::UntypedStorage<8, 16>   mUnkd0c917;
    ::ll::UntypedStorage<8, 8>    mUnka64c85;
    ::ll::UntypedStorage<8, 8>    mUnk31922c;
    ::ll::UntypedStorage<8, 8>    mUnkb92250;
    ::ll::UntypedStorage<8, 8>    mUnkc46d8a;
    ::ll::UntypedStorage<8, 8>    mUnk3dc5d4;
    ::ll::UntypedStorage<8, 8>    mUnk6622a0;
    ::ll::UntypedStorage<8, 16>   mUnke27718;
    ::ll::UntypedStorage<8, 16>   mUnk88d837;
    ::ll::UntypedStorage<8, 16>   mUnk9599c5;
    ::ll::UntypedStorage<8, 8>    mUnk1498bc;
    ::ll::UntypedStorage<8, 16>   mUnkc84d4d;
    ::ll::UntypedStorage<8, 8>    mUnkeee60b;
    ::ll::UntypedStorage<8, 8>    mUnk7757ed;
    ::ll::UntypedStorage<8, 8>    mUnk8b5a69;
    ::ll::UntypedStorage<8, 16>   mUnk8a114f;
    ::ll::UntypedStorage<8, 8>    mUnk2c648f;
    ::ll::UntypedStorage<8, 8>    mUnkef66f4;
    ::ll::UntypedStorage<8, 8>    mUnk5cb7cc;
    ::ll::UntypedStorage<8, 456>  mUnke5c301;
    ::ll::UntypedStorage<8, 8>    mUnkd18639;
    ::ll::UntypedStorage<8, 8>    mUnk67d5dd;
    ::ll::UntypedStorage<8, 8>    mUnkc0bd78;
    ::ll::UntypedStorage<8, 8>    mUnk8ac119;
    ::ll::UntypedStorage<8, 16>   mUnkddfaa0;
    ::ll::UntypedStorage<8, 8>    mUnk82663e;
    ::ll::UntypedStorage<8, 8>    mUnkb6a170;
    ::ll::UntypedStorage<8, 8>    mUnk8673bc;
    ::ll::UntypedStorage<8, 8>    mUnk1187d6;
    ::ll::UntypedStorage<8, 8>    mUnk807b24;
    ::ll::UntypedStorage<8, 8>    mUnke45c86;
    ::ll::UntypedStorage<8, 8>    mUnk1cf921;
    ::ll::UntypedStorage<8, 8>    mUnk70c996;
    ::ll::UntypedStorage<8, 8>    mUnk89400e;
    ::ll::UntypedStorage<8, 8>    mUnk946503;
    ::ll::UntypedStorage<8, 8>    mUnk781ed2;
    ::ll::UntypedStorage<8, 8>    mUnk871dc6;
    ::ll::UntypedStorage<8, 8>    mUnkf2f2ba;
    ::ll::UntypedStorage<8, 8>    mUnkde4441;
    ::ll::UntypedStorage<8, 8>    mUnk8f12bc;
    ::ll::UntypedStorage<8, 8>    mUnkc2e1c6;
    ::ll::UntypedStorage<8, 8>    mUnk3ed686;
    ::ll::UntypedStorage<8, 8>    mUnk45b4b1;
    ::ll::UntypedStorage<8, 8>    mUnk777677;
    ::ll::UntypedStorage<8, 8>    mUnk1d6e6b;
    ::ll::UntypedStorage<8, 8>    mUnk7fca88;
    ::ll::UntypedStorage<8, 8>    mUnk71d6b7;
    ::ll::UntypedStorage<8, 8>    mUnk8d4567;
    ::ll::UntypedStorage<8, 8>    mUnkfdb8ca;
    ::ll::UntypedStorage<8, 8>    mUnkf68a87;
    ::ll::UntypedStorage<8, 8>    mUnk45501b;
    ::ll::UntypedStorage<8, 8>    mUnk10c987;
    ::ll::UntypedStorage<8, 48>   mUnk3703bb;
    ::ll::UntypedStorage<8, 8>    mUnkdd5b99;
    ::ll::UntypedStorage<8, 16>   mUnk1c3779;
    ::ll::UntypedStorage<8, 16>   mUnk4b4e23;
    ::ll::UntypedStorage<8, 24>   mUnk698964;
    ::ll::UntypedStorage<8, 24>   mUnk8d1118;
    ::ll::UntypedStorage<8, 16>   mUnk99fad5;
    ::ll::UntypedStorage<8, 24>   mUnk4f11c0;
    ::ll::UntypedStorage<8, 24>   mUnk205f41;
    ::ll::UntypedStorage<8, 8>    mUnk952a89;
    ::ll::UntypedStorage<8, 8>    mUnk2ac62b;
    ::ll::UntypedStorage<8, 8>    mUnk185e8d;
    ::ll::UntypedStorage<8, 8>    mUnk94b524;
    ::ll::UntypedStorage<8, 8>    mUnk308f25;
    ::ll::UntypedStorage<8, 8>    mUnk5dd8f3;
    ::ll::UntypedStorage<8, 8>    mUnkceb4ab;
    ::ll::UntypedStorage<8, 8>    mUnk50a24d;
    ::ll::UntypedStorage<8, 16>   mUnk976824;
    ::ll::UntypedStorage<8, 8>    mUnkcd32cf;
    ::ll::UntypedStorage<8, 8>    mUnk32d240;
    ::ll::UntypedStorage<8, 16>   mUnkaa8c49;
    ::ll::UntypedStorage<8, 872>  mUnk6546c2;
    ::ll::UntypedStorage<8, 16>   mUnka3a452;
    ::ll::UntypedStorage<8, 8>    mUnk7f0a19;
    ::ll::UntypedStorage<8, 8>    mUnk93ada3;
    ::ll::UntypedStorage<8, 8>    mUnk67f34e;
    ::ll::UntypedStorage<8, 8>    mUnkc456b9;
    ::ll::UntypedStorage<8, 8>    mUnk804e62;
    ::ll::UntypedStorage<8, 8>    mUnk92ee4c;
    ::ll::UntypedStorage<8, 8>    mUnke4e7c9;
    ::ll::UntypedStorage<8, 8>    mUnk5e4634;
    ::ll::UntypedStorage<8, 64>   mUnk12c89f;
    ::ll::UntypedStorage<8, 16>   mUnk42b15f;
    ::ll::UntypedStorage<8, 16>   mUnka8e328;
    ::ll::UntypedStorage<8, 24>   mUnkba1560;
    ::ll::UntypedStorage<8, 16>   mUnk3bcf80;
    ::ll::UntypedStorage<8, 16>   mUnka14281;
    ::ll::UntypedStorage<1, 1>    mUnkd46ea8;
    ::ll::UntypedStorage<8, 8>    mUnk205ada;
    ::ll::UntypedStorage<8, 16>   mUnk41bdf3;
    ::ll::UntypedStorage<8, 16>   mUnkad2805;
    ::ll::UntypedStorage<8, 16>   mUnk6b22bf;
    ::ll::UntypedStorage<8, 64>   mUnkf160e9;
    ::ll::UntypedStorage<8, 64>   mUnk19d968;
    // NOLINTEND
 
public:
    // prevent constructor by default
    MinecraftGame& operator=(MinecraftGame const&);
    MinecraftGame(MinecraftGame const&);
    MinecraftGame();
 
public:
    // virtual functions
    // NOLINTBEGIN
    virtual void initialize() /*override*/;
 
    virtual ~MinecraftGame() /*override*/ = default;
 
    virtual bool stop() /*override*/;
 
    virtual void processActivationArguments(::Bedrock::ActivationArguments const& args) /*override*/;
 
    virtual void audioEngineOn() /*override*/;
 
    virtual void audioEngineOff() /*override*/;
 
    virtual void update() /*override*/;
 
    virtual void play(::std::string const& name, ::Vec3 const& pos, float volume, float pitch) /*override*/;
 
    virtual void playUI(::std::string const& name, float volume, float pitch) /*override*/;
 
    virtual void stopSound(::std::string const& name) /*override*/;
 
    virtual void stopSounds() /*override*/;
 
    virtual void setUISize(int w, int h) /*override*/;
 
    virtual void setRenderingSize(int w, int h) /*override*/;
 
    virtual void recalculateScene() /*override*/;
 
    virtual void setSmoothFontStyle() /*override*/;
 
    virtual void setUIFontStyle() /*override*/;
 
    virtual ::Bedrock::Threading::Async<void> startLocalServerAsync(
        ::std::string const&     levelId,
        ::std::string const&     levelName,
        ::ContentIdentity const& premiumTemplateContentIdentity,
        ::LevelSettings const&   settings,
        ::StartIntent            startIntent
    ) /*override*/;
 
    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
    ) /*override*/;
 
    virtual bool canStartLocalServer() const /*override*/;
 
    virtual bool isAudioInitialized() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::SoundEngine> getSoundEngine() const /*override*/;
 
    virtual ::MusicManager const* getMusicManager() const /*override*/;
 
    virtual ::MusicManager* getMusicManagerNonConst() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ITextBoxController> getTextBoxController() /*override*/;
 
    virtual void onLowMemory(::LowMemorySeverity) /*override*/;
 
    virtual void onAppFocusLost() /*override*/;
 
    virtual void onAppFocusGained() /*override*/;
 
    virtual void onAppPaused() /*override*/;
 
    virtual void onAppUnpaused() /*override*/;
 
    virtual void setReconnectionCookie(
        ::std::optional<::std::variant<
            ::GameConnectionInfoEx,
            ::Social::MultiplayerGameInfo,
            ::ExperienceJoinRequestInfo,
            ::Realms::RealmId>> const& reconnectCookie
    ) /*override*/;
 
    virtual ::std::optional<::std::variant<
        ::GameConnectionInfoEx,
        ::Social::MultiplayerGameInfo,
        ::ExperienceJoinRequestInfo,
        ::Realms::RealmId>>
    getReconnectionCookie() /*override*/;
 
    virtual void onAppPreSuspended() /*override*/;
 
    virtual void onAppSuspended() /*override*/;
 
    virtual void onAppResumed() /*override*/;
 
    virtual void onDeviceLost() /*override*/;
 
    virtual void onAppSurfaceCreated() /*override*/;
 
    virtual void onAppSurfaceDestroyed() /*override*/;
 
    virtual void onOperationModeChanged(::OperationMode newMode) /*override*/;
 
    virtual bool hasNetworkPrivileges(bool onlyWifiAllowed) /*override*/;
 
    virtual void onPlayerLoaded(::IClientInstance& client, ::Player& player) /*override*/;
 
    virtual void onDimensionChanged() /*override*/;
 
    virtual void setDisableInputForAllOtherClients(int id, bool disableStatus) /*override*/;
 
    virtual void onGameEventNotification(::ui::GameEventNotification notification) /*override*/;
 
    virtual void playerListChanged() /*override*/;
 
    virtual void onLevelDestruction(::std::string const& levelId) /*override*/;
 
    virtual void setWorldTransferAction(
        ::std::variant<
            ::LocalWorldTransferActionFunc,
            ::ExternalWorldTransferActionFunc,
            ::RealmTransferActionFunc,
            ::std::monostate>&& worldTransferAction
    ) /*override*/;
 
    virtual ::std::variant<
        ::LocalWorldTransferActionFunc,
        ::ExternalWorldTransferActionFunc,
        ::RealmTransferActionFunc,
        ::std::monostate> const&
    getWorldTransferAction() const /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::WorldTransferAgent> const getWorldTransferAgent() const /*override*/;
 
    virtual void setIsWorldTransferInProgress(bool isWorldTransferInProgress) /*override*/;
 
    virtual bool isWorldTransferInProgress() const /*override*/;
 
    virtual void setResetCallbackObject(::ResetCallbackObject* obj) /*override*/;
 
    virtual void abortPendingGameJoin() /*override*/;
 
    virtual void requestLeaveGame(bool switchScreen, bool sync) /*override*/;
 
    virtual void requestLeaveThenJoinFriendsWorld(::std::string_view serverId) /*override*/;
 
    virtual void requestLeaveGameWithWorldThumbnail() /*override*/;
 
    virtual void requestLeaveGameWithWorldThumbnailThenJoinFriendsWorld(::std::string_view serverId) /*override*/;
 
    virtual void startLeaveGame() /*override*/;
 
    virtual bool isLeaveGameDone() const /*override*/;
 
    virtual void destroyGame() /*override*/;
 
    virtual void setupCommandParser(::IClientInstance& client) /*override*/;
 
    virtual void onClientCreatedLevel(::IClientInstance& client) /*override*/;
 
    virtual ::GameRenderer& getGameRenderer() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IUIDefRepository> getUIDefRepo() const /*override*/;
 
    virtual void joinRealmsGame(
        ::Realms::World const&              realm,
        ::Social::GameConnectionInfo const& gameConnection,
        ::PlayerJoinWorldContext            context
    ) /*override*/;
 
    virtual void joinRealmFromInvite(::Realms::World const& world) /*override*/;
 
    virtual void joinRealmFromConnectLink(::Realms::World const& world, ::PlayerJoinWorldContext context) /*override*/;
 
    virtual void setRealmsLoadingLink(bool state) /*override*/;
 
    virtual void joinRealm(
        ::Realms::World const&                    world,
        ::IMinecraftEventing::RealmConnectionFlow telemetryEventingConnectionFlow,
        ::PlayerJoinWorldContext                  context
    ) /*override*/;
 
    virtual ::Bedrock::Threading::Async<void> joinMultiplayerGame(
        ::Social::MultiplayerGameInfo const& gameInfo,
        ::PlayerJoinWorldContext             context,
        ::OnlineSafetyDialogVisibility       onlineSafetyDialogVisibility
    ) /*override*/;
 
    virtual void joinMultiplayerWithAddress(
        ::Social::GameConnectionInfo gameConnection,
        bool                         joiningLocalServer,
        ::std::string const&         serverName,
        ::std::string const&         worldName,
        ::NetworkType                networkTypeOverride,
        ::std::shared_ptr<bool>      userCancelled,
        ::PlayerJoinWorldContext     context
    ) /*override*/;
 
    virtual void joinRemoteServerWithAddress(
        ::Social::GameConnectionInfo gameConnection,
        ::std::string const&         serverName,
        ::std::string const&         worldName,
        ::NetworkType                networkTypeOverride,
        ::std::shared_ptr<bool>      userCancelled,
        ::PlayerJoinWorldContext     context
    ) /*override*/;
 
    virtual bool isLocalPlayer(::ActorUniqueID const& id) const /*override*/;
 
    virtual void setLeaveGameInProgressAsReadyToContinue() /*override*/;
 
    virtual bool isPrimaryClientInstanceReady() const /*override*/;
 
    virtual void ensureAllClientsAreLeaving() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IClientInstance> getPrimaryClientInstance() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IClientInstance const> getPrimaryClientInstance() const /*override*/;
 
    virtual ::ItemRegistryRef getClientItemRegistry() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem> getNewPlayerSystem() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem const> getNewPlayerSystem() const /*override*/;
 
    virtual ::std::map<::SubClientId, ::std::shared_ptr<::IClientInstance>> getClientInstanceMap() /*override*/;
 
    virtual ::std::map<::SubClientId, ::std::shared_ptr<::IClientInstance const>> getClientInstanceMap() const
        /*override*/;
 
    virtual ::std::shared_ptr<::IClientInstance const>
    tryGetClientInstanceFromPlayerUUID(::mce::UUID const& playerId) const /*override*/;
 
    virtual uint getUIRenderClientMask() const /*override*/;
 
    virtual uint64 getClientInstanceCount() const /*override*/;
 
    virtual void forEachClientInstance(::std::function<void(::IClientInstance&)> callback) /*override*/;
 
    virtual ::LocalPlayer* getPrimaryLocalPlayer() /*override*/;
 
    virtual ::LocalPlayer const* getPrimaryLocalPlayer() const /*override*/;
 
    virtual bool isPrimaryLevelCrossPlatformMultiplayer() const /*override*/;
 
    virtual bool isPrimaryLevelMultiplayer() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GuiData> getPrimaryGuiData() /*override*/;
 
    virtual ::std::shared_ptr<::OptionRegistry> getPrimaryUserOptions() /*override*/;
 
    virtual ::std::shared_ptr<::OptionRegistry const> getPrimaryUserOptions() const /*override*/;
 
    virtual bool isPrimaryUserSigninInProgress() const /*override*/;
 
    virtual void resetInput() /*override*/;
 
    virtual ::PixelCalc const& getDpadScale() const /*override*/;
 
    virtual void setKeyboardForcedHeight(float height, bool isShowSignal) /*override*/;
 
    virtual bool canActivateKeyboard() /*override*/;
 
    virtual void reloadAnimationAndGeometryData(bool sync) /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GeometryGroup> getGeometryGroup() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::BlockCullingGroup> getBlockCullingGroup() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ClientBlockPipeline::SchematicsRepository> getSchematicsRepository() const
        /*override*/;
 
    virtual ::ParticleEffectGroup& getParticleEffectGroup() const /*override*/;
 
    virtual ::DeferredLighting& getDeferredLighting() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ContentAcquisition> getContentAcquisition() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IOfferRepository> getOfferRepository() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TrialManager> getTrialManager() const /*override*/;
 
    virtual bool isTrialManagerInitialized() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PersonaService> getPersonaService() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GatheringManager> getGatheringManager() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ContentCatalogService> getContentCatalogService() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LayoutService> getLayoutService() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LayoutRefreshEventSource> getLayoutRefreshEventSource() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ILayoutServiceCache> getLayoutServiceCache() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::StoreCatalogRepository> getStoreCatalog() const /*override*/;
 
    virtual ::ServiceDrivenImageRepository& getServiceImageRepository() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LibraryRepository> getLibraryRepository() const /*override*/;
 
    virtual ::std::shared_ptr<::ActorAnimationGroup> getActorAnimationGroup() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorAnimationControllerGroup> getActorAnimationControllerGroup() const
        /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository const> getThirdPartyServerRepository() const
        /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository> getThirdPartyServerRepository() /*override*/;
 
    virtual ::std::shared_ptr<::SkinRepository> getSkinRepository() const /*override*/;
 
    virtual ::PersonaRepository& getPersonaRepository() const /*override*/;
 
    virtual ::MarketplaceServicesManager& getMarketplaceServicesManager() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::WorldTemplateManager> getWorldTemplateManager() const /*override*/;
 
    virtual ::World::WorldSystem& getWorldSystem() const /*override*/;
 
    virtual bool isWorldSystemReady() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsSystem> getRealmsSystem() const /*override*/;
 
    virtual ::Social::SocialSystem& getSocialSystem() const /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::Parties::PartySystem> getPartySystem() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Progress::ProgressTips> getUIProgressTips() const /*override*/;
 
    virtual ::IResourcePackRepository& getResourcePackRepository() const /*override*/;
 
    virtual ::ResourcePackManager& getResourcePackManager() const /*override*/;
 
    virtual ::ResourcePackManager& getServerResourcePackManager() /*override*/;
 
    virtual ::PackManifestFactory& getPackManifestFactory() /*override*/;
 
    virtual ::PlayerMessagingService& getPlayerMessagingService() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentKeyProvider const> getKeyProvider() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider const> getAccessibilityProvider() const
        /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider> getAccessibilityProvider() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IContentTierManager const> getContentTierManager() const /*override*/;
 
    virtual ::PackSourceFactory& getPackSourceFactory() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ResourceLoadManager> getResourceLoadManager() /*override*/;
 
    virtual ::ILevelListCache& getLevelListCache() /*override*/;
 
    virtual bool hasAllValidCrossPlatformSkin() const /*override*/;
 
    virtual ::PackDownloadManager& getPackDownloadManager() /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> getLinkedAssetValidator() const /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> getLinkedAssetValidator() /*override*/;
 
    virtual bool isMultiplayerServiceManagerReady() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::MultiplayerServiceManager> getMultiplayerServiceManager() const
        /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::IUserManager> getUserManager() const /*override*/;
 
    virtual ::IMinecraftEventing& getEventing() const /*override*/;
 
    virtual ::ServerInstance* getServerInstance() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ServerInstance> getServerInstanceNonOwnPtr() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ClientNetworkSystem> getClientNetworkSystemPtr() /*override*/;
 
    virtual ::ClientNetworkSystem& getClientNetworkSystem() /*override*/;
 
    virtual ::ClientNetworkSystem const& getClientNetworkSystem() const /*override*/;
 
    virtual ::Bedrock::Profiling::ProfilingOrchestrator const* getProfilingOrchestrator() const /*override*/;
 
    virtual ::Bedrock::Profiling::ProfilingOrchestrator* getMutableProfilingOrchestrator() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActiveDirectoryIdentity> getActiveDirectoryIdentity() /*override*/;
 
    virtual void clearCache() /*override*/;
 
    virtual void releaseClientSubId(::SubClientId subid) /*override*/;
 
    virtual bool isStartingGame() const /*override*/;
 
    virtual bool isSplitscreenJoinEnabled() const /*override*/;
 
    virtual bool canAddSplitscreenSubClient(int controllerId) const /*override*/;
 
    virtual void addSubClientInstanceAndAssociateToUser(int controllerId) /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ControllerIDtoClientMap> retrieveCIDToClientMap() /*override*/;
 
    virtual ::Bedrock::PubSub::Subscription
    registerSplitScreenChangedListener(::std::function<void(uchar)> callback) const /*override*/;
 
    virtual uchar getSplitScreenCount() const /*override*/;
 
    virtual float calculateScreenSizeToResolutionScalar(int const width, int const height) const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GlobalResourcesCrashRecovery const> GetGlobalResourcesCrashRecovery() const
        /*override*/;
 
    virtual bool isReadyToRender() const /*override*/;
 
    virtual bool isShowingLoadingScreen() const /*override*/;
 
    virtual bool isRenderingLoadingScreen() const /*override*/;
 
    virtual void registerUpsellScreen() /*override*/;
 
    virtual ::SceneFactory& getPrimarySceneFactory() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ISceneStack const> getMainSceneStack() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ISceneStack> getMainSceneStack() /*override*/;
 
    virtual ::OreUI::Router& getUIRouter() /*override*/;
 
    virtual ::OreUI::DataProviderManager_DEPRECATED& getDataProviderManager() /*override*/;
 
    virtual ::std::weak_ptr<::RealmsAPI> getRealms() /*override*/;
 
    virtual ::Realms::ContentService& getRealmsContentService() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsServices> getRealmsServices() /*override*/;
 
    virtual ::std::weak_ptr<::ClubsService> getClubsService() /*override*/;
 
    virtual ::std::shared_ptr<::Realms::GenericRequestServiceHandler> getGenericRealmsService() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Realms::SubscriptionService> getRealmsSubscriptionService() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Social::PresenceManager> getPresenceManager() /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::EDUSystems> getEDUSystems() /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::EDUSystems const> getEDUSystems() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Minecraft> getPrimaryMinecraft() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Automation::AutomationClient> getAutomationClient() const /*override*/;
 
    virtual bool isDedicatedServer() const /*override*/;
 
    virtual bool isEduMode() const /*override*/;
 
    virtual void onNetworkMaxPlayersChanged(uint newMaxPlayerCount) /*override*/;
 
    virtual ::IGameModuleApp& getGameModule() /*override*/;
 
    virtual ::IGameModuleShared& getGameModuleShared() /*override*/;
 
    virtual void requestServerShutdown() /*override*/;
 
    virtual void setLaunchedFromLegacyVersion(bool launchedFromLegacyVersion) /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FileArchiver> getFileArchiver() const /*override*/;
 
    virtual bool requestInGamePause(::SubClientId const& subClient, bool status) /*override*/;
 
    virtual ::InputMode getCurrentInputMode() const /*override*/;
 
    virtual void handleInputPaneHidden() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelLoader> getLevelLoader() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ExternalContentManager> getContentManager() /*override*/;
 
    virtual ::IContentManager& getResourceContentManager() /*override*/;
 
    virtual ::std::string getMultiplayerDisabledTextTitle(::MultiplayerLockedContext context) const /*override*/;
 
    virtual ::std::string getMultiplayerDisabledTextBody(::MultiplayerLockedContext context) const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IExternalServerFile> getExternalServer() const /*override*/;
 
    virtual ::std::shared_ptr<::mce::TextureGroup> getTextureGroup() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::mce::TextureGroup> getStoreCacheTextures() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::MinecraftGraphics> getMinecraftGraphics() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TextureAtlas> getTextureAtlas() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IUIRepository> getUIRepository() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::SeasonsRenderer> getSeasonsRenderer() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::Core::FilePathManager> getFilePathManager() /*override*/;
 
    virtual void setUseFontOverrides(bool useOverrides) /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FontRepository const> getFontRepository() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::EmoticonManager const> getEmoticonManager() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper const> getTextToIconMapper() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper> getTextToIconMapper() /*override*/;
 
    virtual bool getMouseGrabbed() const /*override*/;
 
    virtual void navigateToPlayScreenFriendsTab() /*override*/;
 
    virtual bool hasActorResourceDefinitionGroup() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup const> getActorResourceDefinitionGroup() const
        /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup const> getRenderControllerGroup() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup> getRenderControllerGroup() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup>
    getActorResourceDefinitionGroupMutable() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::OreUI::IResourceAllowList> getOreUIResourceAllowList() /*override*/;
 
    virtual ::Bedrock::Threading::Async<::Core::PathBuffer<::std::string>>
    requestScreenshot(::ScreenshotOptions& screenshotOptions) /*override*/;
 
    virtual void onActiveResourcePacksChanged(::ResourcePackManager& mgr) /*override*/;
 
    virtual bool onFullPackStackInvalid() /*override*/;
 
    virtual void onLanguageSubpacksChanged() /*override*/;
 
    virtual void onBaseGamePackDownloadComplete() /*override*/;
 
    virtual void displayActiveDirectoryLoginDialog() /*override*/;
 
    virtual void handleReloadUIDefinitions() /*override*/;
 
    virtual void onPushNotificationReceived(::PushNotificationMessage const& msg) /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::FlightingService> getFlightingService() const /*override*/;
 
    virtual ::std::shared_ptr<::FlightingService> getFlightingServicePtr() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TreatmentPackDownloadMonitor const> getTreatmentPackDownloadMonitor() const
        /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IEntitlementManager> getEntitlementManager() /*override*/;
 
    virtual ::IDlcValidation& getDlcValidation() /*override*/;
 
    virtual ::ServicesManager& getServicesManager() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::SunsettingManager> getSunsettingManager() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::DateManager> getDateManager() const /*override*/;
 
    virtual void grabMouse() /*override*/;
 
    virtual void releaseMouse() /*override*/;
 
    virtual void muteAudio() /*override*/;
 
    virtual void unMuteAudio() /*override*/;
 
    virtual uint64 generateClientId(
        bool                              forceReset,
        bool&                             generatedNewId,
        uint64                            clientIdModifier,
        ::std::shared_ptr<::Social::User> user
    ) /*override*/;
 
    virtual bool isHostingLocalDedicatedServer() const /*override*/;
 
    virtual void shutdownServer() /*override*/;
 
    virtual void pauseContentDownloads() /*override*/;
 
    virtual void resumeContentDownloads() /*override*/;
 
    virtual ::UIMeasureStrategy& getUIMeasureStrategy() /*override*/;
 
    virtual void copyInternalSettingsFolderToExternalLocation() const /*override*/;
 
    virtual void onClientLevelExit(::IClientInstance& exitClient, uint exitCode) /*override*/;
 
    virtual void resetThreadCallbacks() /*override*/;
 
    virtual bool isInGame() const /*override*/;
 
    virtual bool isInServer() const /*override*/;
 
    virtual bool isInRealm() const /*override*/;
 
    virtual void fadeOutMusic() /*override*/;
 
    virtual bool isInitialized() const /*override*/;
 
    virtual bool useMinecraftVersionOfXBLUI() const /*override*/;
 
    virtual int getMaxPlayerCount() const /*override*/;
 
    virtual void setProfilerIsOn(bool val) /*override*/;
 
    virtual void
    onPrimaryUserReconnect(::Social::UserPlatformConnectionResult status, bool isUserInitiated) /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::CubemapBackgroundResources> getCubemapBackgroundResources() /*override*/;
 
    virtual void setAppWillTerminate(bool willTerminate) /*override*/;
 
    virtual ::DeferredTasksManager<::DeferredTaskCategory>& getDeferredTasks() /*override*/;
 
    virtual void onForceCloudSave() /*override*/;
 
    virtual void onOptionsLoadBegin() /*override*/;
 
    virtual void onOptionsLoadComplete() /*override*/;
 
    virtual bool shouldShowRatingsPrompt() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ServerInstanceEventCoordinator>
    getServerInstanceEventCoordinator() /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::IApp> getApp() /*override*/;
 
    virtual bool getSuspended() const /*override*/;
 
    virtual bool isResuming() const /*override*/;
 
    virtual void doPrimaryClientReadyWork(::std::function<void()> workFn) /*override*/;
 
    virtual void doUserManagerReadyWork(::std::function<void()> workFn) /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ScreenshotRecorder> getScreenshotRecorder() /*override*/;
 
    virtual bool isEditorModeEnabled() const /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::ContentLogFileEndPoint> const getContentFileLogEndPoint() const /*override*/;
 
    virtual bool isMusicEnabled() const /*override*/;
 
    virtual void queueCustomMusic(
        ::std::string const& eventName,
        float                volume,
        float                fadeoutSeconds,
        ::MusicRepeatMode    playMode
    ) /*override*/;
 
    virtual void playCustomMusic(
        ::std::string const& eventName,
        float                volume,
        float                fadeoutSeconds,
        ::MusicRepeatMode    playMode
    ) /*override*/;
 
    virtual void setMusicCommandVolumeMultiplier(float volumeMultiplier) /*override*/;
 
    virtual void stopCustomMusic(float fadeoutSeconds) /*override*/;
 
    virtual ::EntityContext& getEntity() const /*override*/;
 
    virtual ::AppSystemRegistry& getAppSystemRegistry() /*override*/;
 
    virtual void onLanguageChanged(::std::string const& code, bool languageSystemInitializing) /*override*/;
 
    virtual void onLanguageKeywordsLoadedFromPack(::PackManifest const& manifest) /*override*/;
 
    virtual void onLanguagesLoaded() /*override*/;
 
    virtual void buildTreatmentPackStack(bool fireEvents) const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelDbEnv> getLevelDbEnv() /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::ChunkSource>
    getClientGenChunkSource(::DimensionType const& dimensionType) /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ProfanityContext> getProfanityContext() /*override*/;
 
    virtual double getGameUpdateDurationInSeconds() const /*override*/;
 
    virtual void queueSubclientRemoval(::SubClientId subid) /*override*/;
 
    virtual void logoffAllSubclients() /*override*/;
 
    virtual void setIsInGame(bool isInGame) /*override*/;
 
    virtual void createClientItemRegistry() /*override*/;
 
    virtual ::Bedrock::NonOwnerPointer<::MinecraftInputHandler> getInput() const /*override*/;
 
    virtual ::std::unique_ptr<::LocalServerLauncher::IGameInterface> createGameInterface() /*override*/;
 
    virtual ::std::unique_ptr<::LocalServerLauncher::IServerInstanceBuilder> createServerBuilder() /*override*/;
 
    virtual ::std::unique_ptr<::LocalServerLauncher::GameDependencies> createGameDependencies() /*override*/;
 
    virtual ::TaskGroup& _getServerInitTaskGroup() /*override*/;
 
    virtual bool isMultiPlayerInitialized() const /*override*/;
 
    virtual bool
    checkMultiPlayerPermission(::std::optional<::Social::MultiplayerServiceIdentifier> service) /*override*/;
 
    virtual bool isPlayingLevel() const /*override*/;
 
    virtual void initImpl() /*override*/;
 
    virtual void refocusMouse(bool lostMouse) /*override*/;
 
    virtual void setMouseType(::Bedrock::Input::PointerType type) /*override*/;
 
    virtual void onNotify(::edu::auth::CredentialsAcquired const& state) /*override*/;
 
    virtual void onNotify(::edu::auth::CredentialsRefreshSuccess const& state) /*override*/;
 
    virtual void onNotify(::edu::auth::GenericCredentialsEvent<::edu::auth::CredsLost> const& state) /*override*/;
 
    virtual bool checkForPiracy() const /*override*/;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::DevConsoleLogger> getDevConsoleLogger() const /*override*/;
 
    virtual void completeServerStartup(
        ::std::shared_ptr<::LocalServerLauncher::ServerInitData> serverInitData,
        ::LocalServerLauncher::ServerLaunchResult&&              result
    ) /*override*/;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI explicit MinecraftGame(::MinecraftGameArguments&& args);
 
    MCAPI void _InitComplete();
 
    MCAPI void _LoadRendererAssets();
 
    MCAPI void _addSubClientInstanceAndAssociateToUserInternal(int controllerId, bool isInitialCheck);
 
    MCAPI void _beginReloadingResources();
 
    MCAPI void _buildClientStack();
 
    MCAPI void _buildClientStartupStack();
 
    MCAPI bool _checkIfEduPreventsPlay();
 
    MCAPI bool _clientUpdate();
 
    MCAPI void _configureLighting();
 
    MCAPI ::LocalServerLauncher::Impl::AllDependencies _createAllDependencies();
 
    MCAPI ::std::shared_ptr<::ClientInstance>
    _createClientInstance(::SubClientId id, ::LatencyGraphDisplay* latencyDisplay, int controller);
 
    MCAPI ::brstd::move_only_function<::std::unique_ptr<::IClientDimensionExtensions>(bool) const>
    _createDimensionExtensionsFactory(bool isClientSide);
 
    MCAPI ::std::unique_ptr<::GameModuleClient> _createGameModuleClient(::SubClientId id);
 
    MCAPI void _createPartySystem();
 
    MCAPI void _createSceneFactory(::IClientInstance& client);
 
    MCAPI void _cycleRoundRobinClientSubId();
 
    MCAPI ::std::unique_ptr<::ResourcePackStack> _deserializeGlobalResourcePacks();
 
    MCAPI void _deviceReinitialization(
        ::SerialWorkList&                                         workList,
        ::std::optional<::dragon::framerenderer::DebugParameters> initDebugOptions
    );
 
    MCAPI void _finishReloadingResources(::ResourcePackManager& mgr, bool fullVanillaPackOnStack);
 
    MCAPI ::Bedrock::Threading::Async<void> _handleMultiplayerServiceJoinResult(
        ::Social::MultiplayerServiceIdentifier const gameServiceProvider,
        ::Social::JoinGameStatus                     succeeded,
        ::Social::MultiplayerGameInfo const&         newGame,
        bool                                         isLan
    );
 
    MCAPI ::SerialWorkList::WorkResult _initAudio();
 
    MCAPI ::SerialWorkList::WorkResult _initCheckStorage();
 
    MCAPI ::SerialWorkList::WorkResult _initClientNetworkSystem();
 
    MCAPI ::SerialWorkList::WorkResult _initCrashReporting();
 
    MCAPI ::SerialWorkList::WorkResult
    _initCreatePrimaryClient(::std::shared_ptr<::MinecraftGame::InitContext> initContext);
 
    MCAPI ::SerialWorkList::WorkResult _initDatabase();
 
    MCAPI ::SerialWorkList::WorkResult _initDefaultFonts();
 
    MCAPI ::SerialWorkList::WorkResult _initDeviceDebugConfig();
 
    MCAPI ::SerialWorkList::WorkResult _initEventing();
 
    MCAPI ::SerialWorkList::WorkResult _initFileSystemSpaceTracking();
 
    MCAPI ::SerialWorkList::WorkResult _initFinish(::std::shared_ptr<::MinecraftGame::InitContext>& initContext);
 
    MCAPI ::SerialWorkList::WorkResult _initFontHandles();
 
    MCAPI ::SerialWorkList::WorkResult _initFontMetadata();
 
    MCAPI ::SerialWorkList::WorkResult _initHideSplashScreen();
 
    MCAPI ::SerialWorkList::WorkResult _initHttp();
 
    MCAPI ::SerialWorkList::WorkResult _initIssueHardwareCursorLoad();
 
    MCAPI ::SerialWorkList::WorkResult _initLoadRendererAssets();
 
    MCAPI ::SerialWorkList::WorkResult _initLoadingBarMaterials();
 
    MCAPI ::SerialWorkList::WorkResult _initLogging();
 
    MCAPI void _initMinecraftGame();
 
    MCAPI ::SerialWorkList::WorkResult _initMultiplayerMgr();
 
    MCAPI ::SerialWorkList::WorkResult _initMultiplayerRequestHandler();
 
    MCAPI ::SerialWorkList::WorkResult _initNetworkSessionOwner();
 
    MCAPI ::SerialWorkList::WorkResult _initNewPlayerSystem();
 
    MCAPI ::SerialWorkList::WorkResult _initNotifyOnActiveResourcePacksChanged();
 
    MCAPI ::SerialWorkList::WorkResult _initOnGameSessionReset();
 
    MCAPI ::SerialWorkList::WorkResult _initOreUIAssets();
 
    MCAPI ::SerialWorkList::WorkResult _initOreUIDataProviderManager();
 
    MCAPI ::SerialWorkList::WorkResult _initOreUIRendering();
 
    MCAPI ::SerialWorkList::WorkResult _initOreUISystem(::std::shared_ptr<::MinecraftGame::InitContext> initContext);
 
    MCAPI ::SerialWorkList::WorkResult _initOreUIViewsCoordinator();
 
    MCAPI ::SerialWorkList::WorkResult _initPacks();
 
    MCAPI ::SerialWorkList::WorkResult _initPartySystem();
 
    MCAPI void _initPerMachineOptionObservers();
 
    MCAPI void _initPerUserOptionObservers(::Bedrock::NotNullNonOwnerPtr<::IClientInstance> const& client);
 
    MCAPI ::SerialWorkList::WorkResult _initPostA();
 
    MCAPI ::SerialWorkList::WorkResult _initPostB();
 
    MCAPI ::SerialWorkList::WorkResult _initPostC();
 
    MCAPI ::SerialWorkList::WorkResult _initPostE();
 
    MCAPI ::SerialWorkList::WorkResult _initPostFontAsync();
 
    MCAPI ::SerialWorkList::WorkResult _initPreCacheOutOfGameViews();
 
    MCAPI ::SerialWorkList::WorkResult
    _initPrimaryClientComplete(::std::shared_ptr<::MinecraftGame::InitContext> initContext);
 
    MCAPI ::SerialWorkList::WorkResult _initPrimaryIdentity();
 
    MCAPI ::SerialWorkList::WorkResult _initProgressTips();
 
    MCAPI ::SerialWorkList::WorkResult _initPushAlwaysActiveScreen();
 
    MCAPI ::SerialWorkList::WorkResult _initRealmsSystem();
 
    MCAPI ::SerialWorkList::WorkResult _initRepopulateLevelInfoCache();
 
    MCAPI ::SerialWorkList::WorkResult _initResourceLoader();
 
    MCAPI void _initServicesManager();
 
    MCAPI ::SerialWorkList::WorkResult _initSocialSystem();
 
    MCAPI ::SerialWorkList::WorkResult _initStep1();
 
    MCAPI ::SerialWorkList::WorkResult _initStep2();
 
    MCAPI ::SerialWorkList::WorkResult _initStep2A();
 
    MCAPI ::SerialWorkList::WorkResult _initStep2B();
 
    MCAPI ::SerialWorkList::WorkResult _initStep3();
 
    MCAPI ::SerialWorkList::WorkResult _initStep5();
 
    MCFOLD ::SerialWorkList::WorkResult _initStorageMigration();
 
    MCAPI ::SerialWorkList::WorkResult _initTTS();
 
    MCAPI ::SerialWorkList::WorkResult _initTestClientInterface();
 
    MCAPI ::SerialWorkList::WorkResult _initTimePlayedNotifier();
 
    MCAPI ::SerialWorkList::WorkResult _initTriggerSignIn();
 
    MCAPI ::SerialWorkList::WorkResult _initUILoadAsyncWait();
 
    MCAPI ::SerialWorkList::WorkResult _initUpdateAppLaunchedCount();
 
    MCAPI ::SerialWorkList::WorkResult _initUpdateFontsBasedOffOfOverrideEnable();
 
    MCAPI ::SerialWorkList::WorkResult _initUser();
 
    MCAPI ::SerialWorkList::WorkResult _initUserComplete();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForContentManager();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForDefaultFontsToLoad();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForDiscoveryService();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForEntitlementCacheLoad();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForFontMetadataToLoad();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForFrameBuilder();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForInitialServicePacks();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForLocalization();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForMainMenuResources();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForOfferLicense();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForOfferRepo();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForOreUIAssets() const;
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForPrimaryUser();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForRepopulateLevelInfoCache();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForResourceRepository();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForSkinRepo();
 
    MCAPI ::SerialWorkList::WorkResult _initWaitForWorldTemplateManager();
 
    MCAPI ::SerialWorkList::WorkResult _initWorldSystem();
 
    MCAPI ::SerialWorkList::WorkResult _initializeFrameBuilder();
 
    MCAPI bool _isGameplayPaused();
 
    MCAPI void _joinMultiplayerAfterTransportLayerDetermined(
        ::Social::GameConnectionInfo gameConnection,
        bool                         joiningLocalServer,
        ::std::string const&         serverName,
        ::std::string const&         worldName,
        ::NetworkType                networkTypeOverride,
        ::PlayerJoinWorldContext     context,
        ::TransportLayer             serverTransportLayer
    );
 
    MCAPI ::Bedrock::Threading::Async<void> _joinMultiplayerGame(
        ::Social::MultiplayerGameInfo const& gameToJoin,
        ::std::string const&                 multiplayerCorrelationId,
        ::PlayerJoinWorldContext             context,
        ::OnlineSafetyDialogVisibility       onlineSafetyDialogVisibility
    );
 
    MCAPI ::SerialWorkList::WorkResult _loadGlobalResourcePacks();
 
    MCAPI void _loadInitialPackResources(::ResourcePackManager& mgr, bool fullVanillaPackOnStack);
 
    MCAPI void _loadLanguageData();
 
    MCAPI void _loadLastGlobalResourcePacksFromFile(bool waitForUIReload);
 
    MCAPI ::SerialWorkList::WorkResult _notifyOnFullVanillaPackOnStack();
 
    MCAPI void _onActiveResourcePacksChanged(::ResourcePackManager& mgr, bool fullVanillaPackOnStack);
 
    MCAPI ::SerialWorkList::WorkResult _onDeviceRestoreFinish();
 
    MCAPI void _onEntitlementsChanged();
 
    MCAPI void _onEntitlementsChangedNotifyUI();
 
    MCAPI void _onInitRemoteSystem(::std::function<void()> syncCompleteCallback);
 
    MCAPI void _onItemAtlasReloaded();
 
    MCAPI void _onPrimaryUserConnectComplete(
        ::Social::UserPlatformConnectionResult status,
        bool                                   runStartScreen,
        bool                                   userInitiated
    );
 
    MCAPI ::SerialWorkList::WorkResult _onResumeBegin();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeFinish();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeHttp();
 
    MCAPI ::SerialWorkList::WorkResult _onResumePrimaryClient();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeQueueFontReloadTextures();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadActors();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadAnimation();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadParticleEffects();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadTextures();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeQueueReloadTexturesAtlas();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeReloadDefaultLighting();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeRestartServices();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeWaitFontReloadTextures();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeWaitPreviousResourceLoads();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadActors();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadAnimation();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadParticleEffects();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadTextures();
 
    MCAPI ::SerialWorkList::WorkResult _onResumeWaitReloadTexturesAtlas();
 
    MCAPI void _onSplitScreenChanged();
 
    MCAPI void _onTTSOptionChanged();
 
    MCAPI void _onTTSOptionChanged(bool enabled);
 
    MCAPI void _onTerrainAtlasReloaded();
 
    MCAPI void _onTextureAtlasStatus(::TextureAtlasStatus const& status);
 
    MCAPI void _onUserSigninXboxLive(uint userId);
 
    MCAPI void _performNetworkReadyActions();
 
    MCAPI void _preCacheOutOfGameViews();
 
    MCAPI void _recomputeResolution();
 
    MCAPI void _registerClientOptionObserver(
        ::SubClientId const                    clientId,
        ::Option*                              option,
        ::std::function<void(::Option const&)> onValueChangeCallback
    );
 
    MCAPI void _registerPrimaryUserOptionLock(::Option* option, ::std::function<void(bool&)> isModifiableCondition);
 
    MCAPI void
    _registerPrimaryUserOptionObserver(::Option* option, ::std::function<void(::Option const&)> onValueChangeCallback);
 
    MCAPI void _reloadLightingTextures();
 
    MCAPI void _removePendingSubclients();
 
    MCAPI void _setupFrameBuilderOptimizer();
 
    MCAPI void _setupRenderer();
 
    MCAPI void _terminateRenderer();
 
    MCAPI void _tryFireWorldLoadPerformance();
 
    MCAPI void _unregisterOnInitUriListeners();
 
    MCAPI void _update();
 
    MCAPI void _updateBiomeBlendingAndAtmosphericScattering(
        float           timeOfDay,
        float           intensityMultiplier,
        ::DimensionType dimensionId
    );
 
    MCAPI void _updateDeferredLightingPresets();
 
    MCAPI void _updateLightingModel();
 
    MCAPI void _updateProfilerLite();
 
    MCAPI void _updateTextureAtlasPBRData(::TextureAtlas const& textureAtlas, bool terrain);
 
    MCAPI ::SerialWorkList::WorkResult _waitForAudio();
 
    MCAPI ::SerialWorkList::WorkResult _waitForFileSystemSpaceTracking();
 
    MCAPI ::SerialWorkList::WorkResult _waitForLoadRendererAssets();
 
    MCAPI ::SerialWorkList::WorkResult _waitForStorageMigration();
 
    MCAPI void adjustClientsUISize();
 
    MCAPI void cleanReloadMaterials();
 
    MCAPI void doInitializationCompleteWork(::std::function<void()> workFn);
 
    MCAPI void endFrame();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IClientInstance> getClientInstance(::SubClientId subid);
 
    MCAPI ::Bedrock::NonOwnerPointer<::ServerNetworkHandler> getServerNetworkHandler();
 
    MCAPI void handleShowUpsellScreen(bool timeExpired);
 
    MCAPI void initEventing();
 
    MCAPI bool isInEDUMultiplayerSession();
 
    MCAPI bool isServerVisible();
 
    MCAPI void onTick();
 
    MCAPI bool primaryLevelExists() const;
 
    MCAPI void startFrame();
 
    MCAPI void tickInput();
 
    MCAPI bool
    tryGetIdForNewSubClient(int controllerId, ::SubClientId& outNewClientId, bool const isInitialCheck) const;
 
    MCAPI void updateAudio(::Bedrock::NotNullNonOwnerPtr<::IClientInstance> const& client, ::Timer const& timer);
 
    MCAPI void updateGraphics(::Bedrock::NotNullNonOwnerPtr<::IClientInstance> const& client, ::Timer const& timer);
    // NOLINTEND
 
public:
    // constructor thunks
    // NOLINTBEGIN
    MCAPI void* $ctor(::MinecraftGameArguments&& args);
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCAPI void $initialize();
 
    MCAPI bool $stop();
 
    MCAPI void $processActivationArguments(::Bedrock::ActivationArguments const& args);
 
    MCAPI void $audioEngineOn();
 
    MCAPI void $audioEngineOff();
 
    MCAPI void $update();
 
    MCAPI void $play(::std::string const& name, ::Vec3 const& pos, float volume, float pitch);
 
    MCAPI void $playUI(::std::string const& name, float volume, float pitch);
 
    MCAPI void $stopSound(::std::string const& name);
 
    MCAPI void $stopSounds();
 
    MCAPI void $setUISize(int w, int h);
 
    MCAPI void $setRenderingSize(int w, int h);
 
    MCAPI void $recalculateScene();
 
    MCAPI void $setSmoothFontStyle();
 
    MCAPI void $setUIFontStyle();
 
    MCAPI ::Bedrock::Threading::Async<void> $startLocalServerAsync(
        ::std::string const&     levelId,
        ::std::string const&     levelName,
        ::ContentIdentity const& premiumTemplateContentIdentity,
        ::LevelSettings const&   settings,
        ::StartIntent            startIntent
    );
 
    MCAPI 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
    );
 
    MCAPI bool $canStartLocalServer() const;
 
    MCAPI bool $isAudioInitialized() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::SoundEngine> $getSoundEngine() const;
 
    MCAPI ::MusicManager const* $getMusicManager() const;
 
    MCAPI ::MusicManager* $getMusicManagerNonConst() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ITextBoxController> $getTextBoxController();
 
    MCAPI void $onLowMemory(::LowMemorySeverity);
 
    MCAPI void $onAppFocusLost();
 
    MCAPI void $onAppFocusGained();
 
    MCAPI void $onAppPaused();
 
    MCAPI void $onAppUnpaused();
 
    MCAPI void $setReconnectionCookie(
        ::std::optional<::std::variant<
            ::GameConnectionInfoEx,
            ::Social::MultiplayerGameInfo,
            ::ExperienceJoinRequestInfo,
            ::Realms::RealmId>> const& reconnectCookie
    );
 
    MCAPI ::std::optional<::std::variant<
        ::GameConnectionInfoEx,
        ::Social::MultiplayerGameInfo,
        ::ExperienceJoinRequestInfo,
        ::Realms::RealmId>>
    $getReconnectionCookie();
 
    MCAPI void $onAppPreSuspended();
 
    MCAPI void $onAppSuspended();
 
    MCAPI void $onAppResumed();
 
    MCAPI void $onDeviceLost();
 
    MCAPI void $onAppSurfaceCreated();
 
    MCAPI void $onAppSurfaceDestroyed();
 
    MCAPI void $onOperationModeChanged(::OperationMode newMode);
 
    MCAPI bool $hasNetworkPrivileges(bool onlyWifiAllowed);
 
    MCAPI void $onPlayerLoaded(::IClientInstance& client, ::Player& player);
 
    MCAPI void $onDimensionChanged();
 
    MCAPI void $setDisableInputForAllOtherClients(int id, bool disableStatus);
 
    MCAPI void $onGameEventNotification(::ui::GameEventNotification notification);
 
    MCAPI void $playerListChanged();
 
    MCAPI void $onLevelDestruction(::std::string const& levelId);
 
    MCAPI void $setWorldTransferAction(
        ::std::variant<
            ::LocalWorldTransferActionFunc,
            ::ExternalWorldTransferActionFunc,
            ::RealmTransferActionFunc,
            ::std::monostate>&& worldTransferAction
    );
 
    MCAPI ::std::variant<
        ::LocalWorldTransferActionFunc,
        ::ExternalWorldTransferActionFunc,
        ::RealmTransferActionFunc,
        ::std::monostate> const&
    $getWorldTransferAction() const;
 
    MCAPI ::Bedrock::NonOwnerPointer<::WorldTransferAgent> const $getWorldTransferAgent() const;
 
    MCAPI void $setIsWorldTransferInProgress(bool isWorldTransferInProgress);
 
    MCAPI bool $isWorldTransferInProgress() const;
 
    MCAPI void $setResetCallbackObject(::ResetCallbackObject* obj);
 
    MCAPI void $abortPendingGameJoin();
 
    MCAPI void $requestLeaveGame(bool switchScreen, bool sync);
 
    MCAPI void $requestLeaveThenJoinFriendsWorld(::std::string_view serverId);
 
    MCAPI void $requestLeaveGameWithWorldThumbnail();
 
    MCAPI void $requestLeaveGameWithWorldThumbnailThenJoinFriendsWorld(::std::string_view serverId);
 
    MCAPI void $startLeaveGame();
 
    MCAPI bool $isLeaveGameDone() const;
 
    MCAPI void $destroyGame();
 
    MCAPI void $setupCommandParser(::IClientInstance& client);
 
    MCAPI void $onClientCreatedLevel(::IClientInstance& client);
 
    MCAPI ::GameRenderer& $getGameRenderer() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IUIDefRepository> $getUIDefRepo() const;
 
    MCAPI void $joinRealmsGame(
        ::Realms::World const&              realm,
        ::Social::GameConnectionInfo const& gameConnection,
        ::PlayerJoinWorldContext            context
    );
 
    MCAPI void $joinRealmFromInvite(::Realms::World const& world);
 
    MCAPI void $joinRealmFromConnectLink(::Realms::World const& world, ::PlayerJoinWorldContext context);
 
    MCAPI void $setRealmsLoadingLink(bool state);
 
    MCAPI void $joinRealm(
        ::Realms::World const&                    world,
        ::IMinecraftEventing::RealmConnectionFlow telemetryEventingConnectionFlow,
        ::PlayerJoinWorldContext                  context
    );
 
    MCAPI ::Bedrock::Threading::Async<void> $joinMultiplayerGame(
        ::Social::MultiplayerGameInfo const& gameInfo,
        ::PlayerJoinWorldContext             context,
        ::OnlineSafetyDialogVisibility       onlineSafetyDialogVisibility
    );
 
    MCAPI void $joinMultiplayerWithAddress(
        ::Social::GameConnectionInfo gameConnection,
        bool                         joiningLocalServer,
        ::std::string const&         serverName,
        ::std::string const&         worldName,
        ::NetworkType                networkTypeOverride,
        ::std::shared_ptr<bool>      userCancelled,
        ::PlayerJoinWorldContext     context
    );
 
    MCAPI void $joinRemoteServerWithAddress(
        ::Social::GameConnectionInfo gameConnection,
        ::std::string const&         serverName,
        ::std::string const&         worldName,
        ::NetworkType                networkTypeOverride,
        ::std::shared_ptr<bool>      userCancelled,
        ::PlayerJoinWorldContext     context
    );
 
    MCAPI bool $isLocalPlayer(::ActorUniqueID const& id) const;
 
    MCAPI void $setLeaveGameInProgressAsReadyToContinue();
 
    MCAPI bool $isPrimaryClientInstanceReady() const;
 
    MCAPI void $ensureAllClientsAreLeaving() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IClientInstance> $getPrimaryClientInstance();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IClientInstance const> $getPrimaryClientInstance() const;
 
    MCAPI ::ItemRegistryRef $getClientItemRegistry() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem> $getNewPlayerSystem();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::NewPlayerSystem const> $getNewPlayerSystem() const;
 
    MCAPI ::std::map<::SubClientId, ::std::shared_ptr<::IClientInstance>> $getClientInstanceMap();
 
    MCAPI ::std::map<::SubClientId, ::std::shared_ptr<::IClientInstance const>> $getClientInstanceMap() const;
 
    MCAPI ::std::shared_ptr<::IClientInstance const>
    $tryGetClientInstanceFromPlayerUUID(::mce::UUID const& playerId) const;
 
    MCAPI uint $getUIRenderClientMask() const;
 
    MCAPI uint64 $getClientInstanceCount() const;
 
    MCAPI void $forEachClientInstance(::std::function<void(::IClientInstance&)> callback);
 
    MCAPI ::LocalPlayer* $getPrimaryLocalPlayer();
 
    MCAPI ::LocalPlayer const* $getPrimaryLocalPlayer() const;
 
    MCAPI bool $isPrimaryLevelCrossPlatformMultiplayer() const;
 
    MCAPI bool $isPrimaryLevelMultiplayer() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::GuiData> $getPrimaryGuiData();
 
    MCAPI ::std::shared_ptr<::OptionRegistry> $getPrimaryUserOptions();
 
    MCAPI ::std::shared_ptr<::OptionRegistry const> $getPrimaryUserOptions() const;
 
    MCAPI bool $isPrimaryUserSigninInProgress() const;
 
    MCAPI void $resetInput();
 
    MCFOLD ::PixelCalc const& $getDpadScale() const;
 
    MCAPI void $setKeyboardForcedHeight(float height, bool isShowSignal);
 
    MCAPI bool $canActivateKeyboard();
 
    MCAPI void $reloadAnimationAndGeometryData(bool sync);
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::GeometryGroup> $getGeometryGroup() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::BlockCullingGroup> $getBlockCullingGroup() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ClientBlockPipeline::SchematicsRepository> $getSchematicsRepository() const;
 
    MCFOLD ::ParticleEffectGroup& $getParticleEffectGroup() const;
 
    MCAPI ::DeferredLighting& $getDeferredLighting() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ContentAcquisition> $getContentAcquisition() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IOfferRepository> $getOfferRepository() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TrialManager> $getTrialManager() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::PersonaService> $getPersonaService() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::GatheringManager> $getGatheringManager() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ContentCatalogService> $getContentCatalogService() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LayoutService> $getLayoutService() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LayoutRefreshEventSource> $getLayoutRefreshEventSource() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ILayoutServiceCache> $getLayoutServiceCache() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::StoreCatalogRepository> $getStoreCatalog() const;
 
    MCAPI ::ServiceDrivenImageRepository& $getServiceImageRepository() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LibraryRepository> $getLibraryRepository() const;
 
    MCAPI ::std::shared_ptr<::ActorAnimationGroup> $getActorAnimationGroup() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActorAnimationControllerGroup> $getActorAnimationControllerGroup() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository const> $getThirdPartyServerRepository() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IThirdPartyServerRepository> $getThirdPartyServerRepository();
 
    MCAPI ::std::shared_ptr<::SkinRepository> $getSkinRepository() const;
 
    MCAPI ::PersonaRepository& $getPersonaRepository() const;
 
    MCAPI ::MarketplaceServicesManager& $getMarketplaceServicesManager() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::WorldTemplateManager> $getWorldTemplateManager() const;
 
    MCAPI ::World::WorldSystem& $getWorldSystem() const;
 
    MCAPI bool $isWorldSystemReady() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsSystem> $getRealmsSystem() const;
 
    MCAPI ::Social::SocialSystem& $getSocialSystem() const;
 
    MCAPI ::Bedrock::NonOwnerPointer<::Parties::PartySystem> $getPartySystem() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Progress::ProgressTips> $getUIProgressTips() const;
 
    MCAPI ::IResourcePackRepository& $getResourcePackRepository() const;
 
    MCAPI ::ResourcePackManager& $getResourcePackManager() const;
 
    MCAPI ::ResourcePackManager& $getServerResourcePackManager();
 
    MCAPI ::PackManifestFactory& $getPackManifestFactory();
 
    MCAPI ::PlayerMessagingService& $getPlayerMessagingService();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IContentKeyProvider const> $getKeyProvider() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider const> $getAccessibilityProvider() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IContentAccessibilityProvider> $getAccessibilityProvider();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IContentTierManager const> $getContentTierManager() const;
 
    MCAPI ::PackSourceFactory& $getPackSourceFactory() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ResourceLoadManager> $getResourceLoadManager();
 
    MCAPI ::ILevelListCache& $getLevelListCache();
 
    MCAPI bool $hasAllValidCrossPlatformSkin() const;
 
    MCAPI ::PackDownloadManager& $getPackDownloadManager();
 
    MCAPI ::Bedrock::NonOwnerPointer<::LinkedAssetValidator> $getLinkedAssetValidator() const;
 
    MCAPI bool $isMultiplayerServiceManagerReady() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Social::MultiplayerServiceManager> $getMultiplayerServiceManager() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Social::IUserManager> $getUserManager() const;
 
    MCAPI ::IMinecraftEventing& $getEventing() const;
 
    MCAPI ::ServerInstance* $getServerInstance();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ServerInstance> $getServerInstanceNonOwnPtr();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ClientNetworkSystem> $getClientNetworkSystemPtr();
 
    MCAPI ::ClientNetworkSystem& $getClientNetworkSystem();
 
    MCAPI ::ClientNetworkSystem const& $getClientNetworkSystem() const;
 
    MCAPI ::Bedrock::Profiling::ProfilingOrchestrator const* $getProfilingOrchestrator() const;
 
    MCAPI ::Bedrock::Profiling::ProfilingOrchestrator* $getMutableProfilingOrchestrator();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActiveDirectoryIdentity> $getActiveDirectoryIdentity();
 
    MCAPI void $clearCache();
 
    MCAPI void $releaseClientSubId(::SubClientId subid);
 
    MCAPI bool $isStartingGame() const;
 
    MCAPI bool $isSplitscreenJoinEnabled() const;
 
    MCAPI bool $canAddSplitscreenSubClient(int controllerId) const;
 
    MCAPI void $addSubClientInstanceAndAssociateToUser(int controllerId);
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ControllerIDtoClientMap> $retrieveCIDToClientMap();
 
    MCAPI ::Bedrock::PubSub::Subscription
    $registerSplitScreenChangedListener(::std::function<void(uchar)> callback) const;
 
    MCAPI uchar $getSplitScreenCount() const;
 
    MCAPI float $calculateScreenSizeToResolutionScalar(int const width, int const height) const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::GlobalResourcesCrashRecovery const> $GetGlobalResourcesCrashRecovery() const;
 
    MCAPI bool $isReadyToRender() const;
 
    MCAPI bool $isShowingLoadingScreen() const;
 
    MCAPI bool $isRenderingLoadingScreen() const;
 
    MCAPI void $registerUpsellScreen();
 
    MCAPI ::SceneFactory& $getPrimarySceneFactory() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ISceneStack const> $getMainSceneStack() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ISceneStack> $getMainSceneStack();
 
    MCAPI ::OreUI::Router& $getUIRouter();
 
    MCAPI ::OreUI::DataProviderManager_DEPRECATED& $getDataProviderManager();
 
    MCAPI ::std::weak_ptr<::RealmsAPI> $getRealms();
 
    MCAPI ::Realms::ContentService& $getRealmsContentService();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Realms::RealmsServices> $getRealmsServices();
 
    MCAPI ::std::weak_ptr<::ClubsService> $getClubsService();
 
    MCAPI ::std::shared_ptr<::Realms::GenericRequestServiceHandler> $getGenericRealmsService();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Realms::SubscriptionService> $getRealmsSubscriptionService();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Social::PresenceManager> $getPresenceManager();
 
    MCAPI ::Bedrock::NonOwnerPointer<::EDUSystems> $getEDUSystems();
 
    MCAPI ::Bedrock::NonOwnerPointer<::EDUSystems const> $getEDUSystems() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Minecraft> $getPrimaryMinecraft();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Automation::AutomationClient> $getAutomationClient() const;
 
    MCFOLD bool $isDedicatedServer() const;
 
    MCFOLD bool $isEduMode() const;
 
    MCAPI void $onNetworkMaxPlayersChanged(uint newMaxPlayerCount);
 
    MCAPI ::IGameModuleApp& $getGameModule();
 
    MCAPI ::IGameModuleShared& $getGameModuleShared();
 
    MCAPI void $requestServerShutdown();
 
    MCAPI void $setLaunchedFromLegacyVersion(bool launchedFromLegacyVersion);
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FileArchiver> $getFileArchiver() const;
 
    MCAPI bool $requestInGamePause(::SubClientId const& subClient, bool status);
 
    MCAPI ::InputMode $getCurrentInputMode() const;
 
    MCAPI void $handleInputPaneHidden();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LevelLoader> $getLevelLoader();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ExternalContentManager> $getContentManager();
 
    MCAPI ::IContentManager& $getResourceContentManager();
 
    MCAPI ::std::string $getMultiplayerDisabledTextTitle(::MultiplayerLockedContext context) const;
 
    MCAPI ::std::string $getMultiplayerDisabledTextBody(::MultiplayerLockedContext context) const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IExternalServerFile> $getExternalServer() const;
 
    MCAPI ::std::shared_ptr<::mce::TextureGroup> $getTextureGroup() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::mce::TextureGroup> $getStoreCacheTextures() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::MinecraftGraphics> $getMinecraftGraphics();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TextureAtlas> $getTextureAtlas();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IUIRepository> $getUIRepository() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::SeasonsRenderer> $getSeasonsRenderer();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::Core::FilePathManager> $getFilePathManager();
 
    MCAPI void $setUseFontOverrides(bool useOverrides);
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FontRepository const> $getFontRepository() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::EmoticonManager const> $getEmoticonManager() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper const> $getTextToIconMapper() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TextToIconMapper> $getTextToIconMapper();
 
    MCAPI bool $getMouseGrabbed() const;
 
    MCAPI void $navigateToPlayScreenFriendsTab();
 
    MCAPI bool $hasActorResourceDefinitionGroup() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup const> $getActorResourceDefinitionGroup() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup const> $getRenderControllerGroup() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::RenderControllerGroup> $getRenderControllerGroup();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ActorResourceDefinitionGroup> $getActorResourceDefinitionGroupMutable();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::OreUI::IResourceAllowList> $getOreUIResourceAllowList();
 
    MCAPI ::Bedrock::Threading::Async<::Core::PathBuffer<::std::string>>
    $requestScreenshot(::ScreenshotOptions& screenshotOptions);
 
    MCAPI void $onActiveResourcePacksChanged(::ResourcePackManager& mgr);
 
    MCAPI bool $onFullPackStackInvalid();
 
    MCAPI void $onLanguageSubpacksChanged();
 
    MCAPI void $onBaseGamePackDownloadComplete();
 
    MCAPI void $displayActiveDirectoryLoginDialog();
 
    MCAPI void $handleReloadUIDefinitions();
 
    MCAPI void $onPushNotificationReceived(::PushNotificationMessage const& msg);
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::FlightingService> $getFlightingService() const;
 
    MCAPI ::std::shared_ptr<::FlightingService> $getFlightingServicePtr() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::TreatmentPackDownloadMonitor const> $getTreatmentPackDownloadMonitor() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IEntitlementManager> $getEntitlementManager();
 
    MCAPI ::IDlcValidation& $getDlcValidation();
 
    MCAPI ::ServicesManager& $getServicesManager();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::SunsettingManager> $getSunsettingManager();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::DateManager> $getDateManager() const;
 
    MCAPI void $grabMouse();
 
    MCAPI void $releaseMouse();
 
    MCAPI void $muteAudio();
 
    MCAPI void $unMuteAudio();
 
    MCAPI uint64 $generateClientId(
        bool                              forceReset,
        bool&                             generatedNewId,
        uint64                            clientIdModifier,
        ::std::shared_ptr<::Social::User> user
    );
 
    MCAPI bool $isHostingLocalDedicatedServer() const;
 
    MCAPI void $shutdownServer();
 
    MCAPI void $pauseContentDownloads();
 
    MCAPI void $resumeContentDownloads();
 
    MCAPI ::UIMeasureStrategy& $getUIMeasureStrategy();
 
    MCFOLD void $copyInternalSettingsFolderToExternalLocation() const;
 
    MCAPI void $onClientLevelExit(::IClientInstance& exitClient, uint exitCode);
 
    MCAPI void $resetThreadCallbacks();
 
    MCAPI bool $isInGame() const;
 
    MCAPI bool $isInServer() const;
 
    MCAPI bool $isInRealm() const;
 
    MCAPI void $fadeOutMusic();
 
    MCAPI bool $isInitialized() const;
 
    MCFOLD bool $useMinecraftVersionOfXBLUI() const;
 
    MCAPI int $getMaxPlayerCount() const;
 
    MCAPI void $setProfilerIsOn(bool val);
 
    MCAPI void $onPrimaryUserReconnect(::Social::UserPlatformConnectionResult status, bool isUserInitiated);
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::CubemapBackgroundResources> $getCubemapBackgroundResources();
 
    MCAPI void $setAppWillTerminate(bool willTerminate);
 
    MCAPI ::DeferredTasksManager<::DeferredTaskCategory>& $getDeferredTasks();
 
    MCFOLD void $onForceCloudSave();
 
    MCAPI void $onOptionsLoadBegin();
 
    MCAPI void $onOptionsLoadComplete();
 
    MCAPI bool $shouldShowRatingsPrompt() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ServerInstanceEventCoordinator> $getServerInstanceEventCoordinator();
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::IApp> $getApp();
 
    MCAPI bool $getSuspended() const;
 
    MCAPI bool $isResuming() const;
 
    MCAPI void $doPrimaryClientReadyWork(::std::function<void()> workFn);
 
    MCAPI void $doUserManagerReadyWork(::std::function<void()> workFn);
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::ScreenshotRecorder> $getScreenshotRecorder();
 
    MCAPI bool $isEditorModeEnabled() const;
 
    MCAPI ::Bedrock::NonOwnerPointer<::ContentLogFileEndPoint> const $getContentFileLogEndPoint() const;
 
    MCAPI bool $isMusicEnabled() const;
 
    MCAPI void
    $queueCustomMusic(::std::string const& eventName, float volume, float fadeoutSeconds, ::MusicRepeatMode playMode);
 
    MCAPI void
    $playCustomMusic(::std::string const& eventName, float volume, float fadeoutSeconds, ::MusicRepeatMode playMode);
 
    MCAPI void $setMusicCommandVolumeMultiplier(float volumeMultiplier);
 
    MCAPI void $stopCustomMusic(float fadeoutSeconds);
 
    MCAPI ::EntityContext& $getEntity() const;
 
    MCAPI ::AppSystemRegistry& $getAppSystemRegistry();
 
    MCAPI void $onLanguageChanged(::std::string const& code, bool languageSystemInitializing);
 
    MCFOLD void $onLanguageKeywordsLoadedFromPack(::PackManifest const& manifest);
 
    MCFOLD void $onLanguagesLoaded();
 
    MCAPI void $buildTreatmentPackStack(bool fireEvents) const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::LevelDbEnv> $getLevelDbEnv();
 
    MCAPI ::Bedrock::NonOwnerPointer<::ChunkSource> $getClientGenChunkSource(::DimensionType const& dimensionType);
 
    MCFOLD ::Bedrock::NotNullNonOwnerPtr<::ProfanityContext> $getProfanityContext();
 
    MCAPI double $getGameUpdateDurationInSeconds() const;
 
    MCAPI void $queueSubclientRemoval(::SubClientId subid);
 
    MCAPI void $logoffAllSubclients();
 
    MCAPI void $setIsInGame(bool isInGame);
 
    MCAPI void $createClientItemRegistry();
 
    MCAPI ::Bedrock::NonOwnerPointer<::MinecraftInputHandler> $getInput() const;
 
    MCAPI ::std::unique_ptr<::LocalServerLauncher::IGameInterface> $createGameInterface();
 
    MCAPI ::std::unique_ptr<::LocalServerLauncher::IServerInstanceBuilder> $createServerBuilder();
 
    MCAPI ::std::unique_ptr<::LocalServerLauncher::GameDependencies> $createGameDependencies();
 
    MCAPI ::TaskGroup& $_getServerInitTaskGroup();
 
    MCAPI bool $isMultiPlayerInitialized() const;
 
    MCAPI bool $checkMultiPlayerPermission(::std::optional<::Social::MultiplayerServiceIdentifier> service);
 
    MCAPI bool $isPlayingLevel() const;
 
    MCAPI void $initImpl();
 
    MCAPI void $refocusMouse(bool lostMouse);
 
    MCAPI void $setMouseType(::Bedrock::Input::PointerType type);
 
    MCAPI void $onNotify(::edu::auth::CredentialsAcquired const& state);
 
    MCFOLD void $onNotify(::edu::auth::CredentialsRefreshSuccess const& state);
 
    MCFOLD void $onNotify(::edu::auth::GenericCredentialsEvent<::edu::auth::CredsLost> const& state);
 
    MCAPI bool $checkForPiracy() const;
 
    MCAPI ::Bedrock::NotNullNonOwnerPtr<::DevConsoleLogger> $getDevConsoleLogger() const;
 
    MCAPI void $completeServerStartup(
        ::std::shared_ptr<::LocalServerLauncher::ServerInitData> serverInitData,
        ::LocalServerLauncher::ServerLaunchResult&&              result
    );
    // NOLINTEND
};