ILevel.h

#pragma once
 
#include "mc/_HeaderOutputPredefine.h"
 
// auto generated inclusion list
#include "mc/common/SubClientId.h"
#include "mc/comprehensive/ParticleType.h"
#include "mc/deps/core/file/PathBuffer.h"
#include "mc/deps/core/utility/EnableNonOwnerReferences.h"
#include "mc/deps/core/utility/NonOwnerPointer.h"
#include "mc/deps/game_refs/OwnerPtr.h"
#include "mc/deps/game_refs/StackRefResult.h"
#include "mc/deps/game_refs/WeakRef.h"
#include "mc/deps/shared_types/legacy/Difficulty.h"
#include "mc/deps/shared_types/legacy/LevelEvent.h"
#include "mc/deps/shared_types/legacy/LevelSoundEvent.h"
#include "mc/network/GamePublishSetting.h"
#include "mc/server/commands/CurrentCmdVersion.h"
#include "mc/util/Factory.h"
#include "mc/util/IDType.h"
#include "mc/util/OwnerPtrFactory.h"
#include "mc/util/TagRegistry.h"
#include "mc/world/actor/ActorEvent.h"
#include "mc/world/level/BlockDestroySound.h"
#include "mc/world/level/CommandOriginSystem.h"
#include "mc/world/level/GameType.h"
#include "mc/world/level/storage/StorageVersion.h"
 
// auto generated forward declare list
// clang-format off
class Abilities;
class Actor;
class ActorAnimationControllerGroup;
class ActorAnimationGroup;
class ActorDamageSource;
class ActorDefinitionGroup;
class ActorDimensionTransferManager;
class ActorEventBroadcaster;
class ActorEventCoordinator;
class ActorFactory;
class ActorFetcher;
class ActorInfoRegistry;
class ActorRuntimeID;
class ActorRuntimeIDManager;
class ActorSoundIdentifier;
class AutomationBehaviorTreeGroup;
class BehaviorFactory;
class BiomeComponentFactory;
class BiomeManager;
class BiomeRegistry;
class Block;
class BlockChangeContext;
class BlockDefinitionGroup;
class BlockEventCoordinator;
class BlockPalette;
class BlockPos;
class BlockReducer;
class BlockSource;
class BlockType;
class BlockTypeRegistry;
class BossEventSubscriptionManager;
class CameraPresets;
class ChangeDimensionRequest;
class ChunkGenerationManager;
class ChunkPos;
class ChunkSource;
class ChunkTickOffsetManager;
class ChunkTickRangeManager;
class ChunkViewSource;
class ClientPlayerEventCoordinator;
class Command;
class CommandOrigin;
class CompoundTag;
class Dimension;
class DimensionConversionData;
class DimensionManager;
class DisplayActorManager;
class EducationSettingsManager;
class EntityContext;
class EntityRegistry;
class EntitySystems;
class Experiments;
class Explosion;
class FeatureRegistry;
class FeatureTypeFactory;
class GameRules;
class GameplayUserManager;
class HashedString;
class HitResult;
class HitResultWrapper;
class IConstBlockSource;
class IContainerRegistryAccess;
class IContainerRegistryTracker;
class IDynamicContainerSerialization;
class ILevelRandom;
class IMinecraftEventing;
class IRandom;
class ISubChunkLighter;
class IUnknownBlockTypeRegistry;
class IWorldRegistriesProvider;
class InternalComponentRegistry;
class ItemEventCoordinator;
class ItemRegistryRef;
class JigsawStructureRegistry;
class LayeredAbilities;
class Level;
class LevelBlockDestroyer;
class LevelChunk;
class LevelChunkEventManager;
class LevelChunkMetaDataManager;
class LevelChunkPerformanceTelemetry;
class LevelData;
class LevelEventCoordinator;
class LevelEventManager;
class LevelListener;
class LevelSeed64;
class LevelSettings;
class LevelSoundManager;
class LevelStorage;
class LootTables;
class MapDataManager;
class MapItemSavedData;
class Mob;
class MolangPackSettingsCache;
class MolangVariableMap;
class NavigationComponent;
class NetEventCallback;
class NetworkIdentifier;
class PacketSender;
class Path;
class PauseManager;
class PermissionsHandler;
class PhotoManager;
class PhotoStorage;
class Player;
class PlayerAbilitiesManager;
class PlayerDeathManager;
class PlayerDimensionTransferManager;
class PlayerEventCoordinator;
class PlayerListEntry;
class PlayerListManager;
class PlayerLocationReceiver;
class PlayerMovementSettingsManager;
class PlayerPermissionsManager;
class PlayerPermissionsSynchroniser;
class PortalForcer;
class ProjectileFactory;
class PropertyGroupManager;
class Random;
class Recipes;
class ResourcePackManager;
class SavedDataStorage;
class Scheduler;
class Scoreboard;
class ScriptDeferredEventCoordinator;
class ScriptingEventCoordinator;
class SerializedSkinRef;
class ServerNetworkEventCoordinator;
class ServerParticleManager;
class ServerPlayerEventCoordinator;
class ServerPlayerSleepManager;
class SoundPlayerInterface;
class Spawner;
class StartGamePacket;
class StrictEntityContext;
class StructureManager;
class StructureSpawnRegistry;
class SubChunkPacket;
class SurfaceBuilderRegistry;
class TagCacheManager;
class TaskGroup;
class TempEPtrManager;
class TickDeltaTimeManager;
class TickTimeManager;
class TickingAreaList;
class TickingAreasManager;
class TradeTables;
class TrimMaterialRegistry;
class TrimPatternRegistry;
class UserEntityIdentifierComponent;
class Vec3;
class VolumeEntityManagerServer;
class WeakEntityRef;
class WorldClockRegistry;
class _TickPtr;
struct ActorDimensionTransferRequest;
struct ActorUniqueID;
struct AdventureSettings;
struct BiomeJsonDocumentGlueResolvedBiomeData;
struct Bounds;
struct BreakingItemParticleData;
struct DerivedDimensionArguments;
struct DimensionType;
struct LevelTagIDType;
struct LevelTagSetIDType;
struct PlaySoundOptions;
struct PlayerMovementSettings;
struct PlayerSleepStatus;
struct PlayerSpawnDimensionResolution;
struct ResolvedItemIconInfo;
struct Tick;
namespace GameModeExt { struct MessengerFactory; }
namespace PlayerCapabilities { struct ISharedController; }
namespace PositionTrackingDB { class PositionTrackingDBClient; }
namespace PositionTrackingDB { class PositionTrackingDBServer; }
namespace ServerInitialization { class IServerInitializer; }
namespace SharedTypes::v1_26_50 { struct CameraPreset; }
namespace VoxelShapes { class VoxelShapeRegistry; }
namespace cereal { struct ReflectionCtx; }
namespace cg { class ImageBuffer; }
namespace mce { class Color; }
namespace mce { class UUID; }
class BaseLightTextureImageBuilder;
class CameraRegistry;
class ClientLevel;
class Particle;
class SubChunkManager;
class SubChunkRequestManager;
class TrustedSkinHelper;
struct ScreenshotOptions;
// clang-format on
 
class ILevel : public ::Bedrock::EnableNonOwnerReferences {
public:
    // virtual functions
    // NOLINTBEGIN
    virtual ~ILevel() /*override*/ = default;
 
    virtual bool initialize(
        ::std::string const&   levelName,
        ::LevelSettings const& levelSettings,
        ::Experiments const&   experiments,
        ::std::string const*   levelId,
        ::std::optional<::std::reference_wrapper<
            ::std::unordered_map<::std::string, ::std::unique_ptr<::BiomeJsonDocumentGlueResolvedBiomeData>>>>
                                                    biomeIdToResolvedData,
        ::ServerInitialization::IServerInitializer* init
    ) = 0;
 
    virtual void startLeaveGame() = 0;
 
    virtual bool isLeaveGameDone() = 0;
 
    virtual bool isDimensionTypeActive(::DimensionType dimensionType) const = 0;
 
    virtual ::WeakRef<::Dimension> getOrCreateDimension(::DimensionType dimensionType) = 0;
 
    virtual ::WeakRef<::Dimension> getDimension(::DimensionType id) const = 0;
 
    virtual ::PlayerSpawnDimensionResolution resolvePlayerSpawnDimension(::CompoundTag const* playerTag) const = 0;
 
    virtual void forEachDimension(::std::function<bool(::Dimension&)> callback) = 0;
 
    virtual void forEachDimension(::std::function<bool(::Dimension const&)> callback) const = 0;
 
    virtual ::DimensionManager& getDimensionManager() = 0;
 
    virtual ::DimensionManager const& getDimensionManager() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::DimensionManager> getDimensionManagerNonOwner() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::DimensionManager const> getDimensionManagerNonOwner() const = 0;
 
    virtual uint getChunkTickRange() const = 0;
 
    virtual ::ChunkTickRangeManager const& getChunkTickRangeManager() const = 0;
 
    virtual ::PortalForcer& getPortalForcer() = 0;
 
    virtual void requestPlayerChangeDimension(::Player& player, ::ChangeDimensionRequest&& changeRequest) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerDimensionTransferManager> getPlayerDimensionTransferManager() = 0;
 
    virtual void
    entityChangeDimension(::Actor& entity, ::ActorDimensionTransferRequest const& actorDimensionTransferRequest) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorDimensionTransferManager> getActorDimensionTransferManager() = 0;
 
    virtual ::Spawner& getSpawner() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::BossEventSubscriptionManager> getBossEventSubscriptionManager() = 0;
 
    virtual ::ProjectileFactory& getProjectileFactory() const = 0;
 
    virtual ::ActorDefinitionGroup* getEntityDefinitions() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorAnimationGroup> getActorAnimationGroup() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::ActorAnimationControllerGroup> getActorAnimationControllerGroup() const = 0;
 
    virtual ::BlockDefinitionGroup* getBlockDefinitions() const = 0;
 
    virtual ::PropertyGroupManager& getActorPropertyGroup() const = 0;
 
    virtual ::CameraPresets const& getCameraPresets() const = 0;
 
    virtual ::CameraPresets& getCameraPresets() = 0;
 
    virtual ::SharedTypes::v1_26_50::CameraPreset const* getCameraPreset(int presetIndex) const = 0;
 
    virtual bool getDisablePlayerInteractions() const = 0;
 
    virtual void setDisablePlayerInteractions(bool const disable) = 0;
 
    virtual ::AutomationBehaviorTreeGroup& getAutomationBehaviorTreeGroup() const = 0;
 
    virtual ::BehaviorFactory& getBehaviorFactory() const = 0;
 
    virtual ::SharedTypes::Legacy::Difficulty getDifficulty() const = 0;
 
    virtual ::InternalComponentRegistry& getInternalComponentRegistry() const = 0;
 
    virtual ::DimensionConversionData getDimensionConversionData() const = 0;
 
    virtual float getSpecialMultiplier(::DimensionType dimensionType) const = 0;
 
    virtual bool hasCommandsEnabled() const = 0;
 
    virtual bool useMsaGamertagsOnly() const = 0;
 
    virtual void setMsaGamertagsOnly(bool msaGamertagsOnly) = 0;
 
    virtual ::Actor* addEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity) = 0;
 
    virtual ::Actor* addGlobalEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity) = 0;
 
    virtual ::Actor* addAutonomousEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity) = 0;
 
    virtual void addUser(::OwnerPtr<::EntityContext> userEntity) = 0;
 
    virtual ::Actor* addDisplayEntity(::BlockSource& region, ::OwnerPtr<::EntityContext> entity) = 0;
 
    virtual ::Actor* putEntity(
        ::BlockSource&              region,
        ::ActorUniqueID             id,
        ::ActorRuntimeID            runtimeId,
        ::OwnerPtr<::EntityContext> entity
    ) = 0;
 
    virtual ::Actor* putEntity(::BlockSource& region, ::ActorUniqueID id, ::OwnerPtr<::EntityContext> entity) = 0;
 
    virtual void removeDisplayEntity(::WeakEntityRef entity) = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::DisplayActorManager> getDisplayActorManager() = 0;
 
    virtual void suspendPlayer(::Player& player) = 0;
 
    virtual void resumePlayer(::Player& player) = 0;
 
    virtual bool isPlayerSuspended(::Player& player) const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GameplayUserManager> getGameplayUserManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::GameplayUserManager const> getGameplayUserManager() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::PlayerLocationReceiver> getPlayerLocationReceiver() = 0;
 
    virtual ::OwnerPtr<::EntityContext> removeActorAndTakeEntity(::WeakEntityRef entityRef) = 0;
 
    virtual ::OwnerPtr<::EntityContext> removeActorFromWorldAndTakeEntity(::WeakEntityRef entityRef) = 0;
 
    virtual ::OwnerPtr<::EntityContext> takeEntity(::WeakEntityRef entityRef, ::LevelChunk& lc) = 0;
 
    virtual ::StrictEntityContext fetchStrictEntity(::ActorUniqueID actorId, bool getRemoved) const = 0;
 
    virtual ::Actor* fetchEntity(::ActorUniqueID actorId, bool getRemoved) const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorFetcher const> getActorFetcher() const = 0;
 
    virtual ::Actor* getRuntimeEntity(::ActorRuntimeID actorId, bool getRemoved) const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorRuntimeIDManager> getActorRuntimeIDManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ActorRuntimeIDManager const> getActorRuntimeIDManager() const = 0;
 
    virtual ::Mob* getMob(::ActorUniqueID mobId) const = 0;
 
    virtual ::Player* getPlayer(::std::string const& name) const = 0;
 
    virtual ::Player* getPlayer(::mce::UUID const& uuid) const = 0;
 
    virtual ::Player* getPlayer(::ActorUniqueID entityID) const = 0;
 
    virtual ::Player* getPlayerByXuid(::std::string const& xuid) const = 0;
 
    virtual ::Player* getPlatformPlayer(::std::string const& platformOnlineId) const = 0;
 
    virtual ::Player* getPlayerFromServerId(::std::string const& serverId) const = 0;
 
    virtual ::Player* getRuntimePlayer(::ActorRuntimeID runtimeId) const = 0;
 
    virtual int getNumRemotePlayers() const = 0;
 
    virtual ::Player* getPrimaryLocalPlayer() const = 0;
 
    virtual ::IMinecraftEventing& getEventing() = 0;
 
    virtual ::mce::Color getPlayerColor(::Player const& player) const = 0;
 
    virtual ::Tick const& getCurrentTick() const = 0;
 
    virtual ::Tick const getCurrentServerTick() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TickDeltaTimeManager const> getTickDeltaTimeManager() const = 0;
 
    virtual ::std::shared_ptr<::VoxelShapes::VoxelShapeRegistry const> getShapeRegistry() const = 0;
 
    virtual ::std::shared_ptr<::VoxelShapes::VoxelShapeRegistry> getMutableShapeRegistry() const = 0;
 
    virtual ::BiomeRegistry const& getBiomeRegistry() const = 0;
 
    virtual ::BiomeRegistry& getBiomeRegistry() = 0;
 
    virtual ::BlockPalette const& getBlockPalette() const = 0;
 
    virtual ::BlockPalette& getBlockPalette() = 0;
 
    virtual ::FeatureRegistry const& getFeatureRegistry() const = 0;
 
    virtual ::FeatureRegistry& getFeatureRegistry() = 0;
 
    virtual ::FeatureTypeFactory const& getFeatureTypeFactory() const = 0;
 
    virtual ::FeatureTypeFactory& getFeatureTypeFactory() = 0;
 
    virtual ::JigsawStructureRegistry const& getJigsawStructureRegistry() const = 0;
 
    virtual ::JigsawStructureRegistry& getJigsawStructureRegistry() = 0;
 
    virtual ::StructureSpawnRegistry const& getStructureSpawnRegistry() const = 0;
 
    virtual ::StructureSpawnRegistry& getStructureSpawnRegistry() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::StructureManager> const getStructureManager() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::StructureManager> getStructureManager() = 0;
 
    virtual ::BiomeComponentFactory const& getBiomeComponentFactory() const = 0;
 
    virtual ::BiomeComponentFactory& getBiomeComponentFactory() = 0;
 
    virtual ::SurfaceBuilderRegistry const& getSurfaceBuilderRegistry() const = 0;
 
    virtual ::SurfaceBuilderRegistry& getSurfaceBuilderRegistry() = 0;
 
    virtual ::BiomeManager const& getBiomeManager() const = 0;
 
    virtual ::BiomeManager& getBiomeManager() = 0;
 
    virtual ::OwnerPtrFactory<::Dimension, ::DerivedDimensionArguments&&> const& getDimensionFactory() const = 0;
 
    virtual ::OwnerPtrFactory<::Dimension, ::DerivedDimensionArguments&&>& getDimensionFactory() = 0;
 
    virtual ::Factory<::BaseLightTextureImageBuilder, ::Level&, ::Scheduler&> const&
    getLightTextureImageBuilderFactory() const = 0;
 
    virtual ::Factory<::BaseLightTextureImageBuilder, ::Level&, ::Scheduler&>& getLightTextureImageBuilderFactory() = 0;
 
    virtual ::IWorldRegistriesProvider const& getWorldRegistriesProvider() const = 0;
 
    virtual ::IWorldRegistriesProvider& getWorldRegistriesProvider() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::WorldClockRegistry const> const getWorldClockRegistry() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::WorldClockRegistry> getWorldClockRegistry() = 0;
 
    virtual void addListener(::LevelListener& listener) = 0;
 
    virtual void removeListener(::LevelListener& listener) = 0;
 
    virtual void tickEntities() = 0;
 
    virtual void tickEntitySystems() = 0;
 
    virtual ::StackRefResult<::PauseManager> getPauseManager() = 0;
 
    virtual ::StackRefResult<::PauseManager const> getPauseManager() const = 0;
 
    virtual void onPlayerDeath(::Player& player, ::ActorDamageSource const& source) = 0;
 
    virtual void tick() = 0;
 
    virtual bool explode(
        ::BlockSource& region,
        ::Actor*       source,
        ::Vec3 const&  pos,
        float          explosionRadius,
        bool           fire,
        bool           breaksBlocks,
        float          maxResistance,
        bool           allowUnderwater
    ) = 0;
 
    virtual bool explode(::Explosion& explosion) = 0;
 
    virtual void
    spawnParticleEffect(::std::string const& effectName, ::Vec3 const& spawnLocation, ::Dimension* dimension) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ServerParticleManager> getServerParticleManager() = 0;
 
    virtual void denyEffect(::BlockSource& region, ::Vec3 const& pos) = 0;
 
    virtual void potionSplash(::Vec3 const& pos, ::mce::Color const& color, bool instantaneousEffect) = 0;
 
    virtual bool extinguishFire(::BlockSource& region, ::BlockPos const& pos, uchar face, ::Actor* source) = 0;
 
    virtual ::std::unique_ptr<::Path>
    findPath(::Actor& from, int xBest, int yBest, int zBest, ::NavigationComponent& navigation) = 0;
 
    virtual ::std::unique_ptr<::Path> findPath(::Actor& from, ::Actor const& to, ::NavigationComponent& navigation) = 0;
 
    virtual void updateSleepingPlayerList() = 0;
 
    virtual void setSleepStatus(::PlayerSleepStatus const& status) = 0;
 
    virtual ::PlayerSleepStatus getSleepStatus() const = 0;
 
    virtual int getTime() const = 0;
 
    virtual void setTime(int time) = 0;
 
    virtual uint getSeed() = 0;
 
    virtual ::LevelSeed64 getLevelSeed64() const = 0;
 
    virtual ::BlockPos const& getSharedSpawnPos() const = 0;
 
    virtual void setDefaultSpawn(::BlockPos const& spawnPos) = 0;
 
    virtual ::BlockPos const& getDefaultSpawn() const = 0;
 
    virtual void setDefaultGameType(::GameType gameType) = 0;
 
    virtual ::GameType getDefaultGameType() const = 0;
 
    virtual void setDifficulty(::SharedTypes::Legacy::Difficulty difficulty) = 0;
 
    virtual ::GameModeExt::MessengerFactory createMessengerFactory() const = 0;
 
    virtual void setMultiplayerGameIntent(bool multiplayerGame) = 0;
 
    virtual bool getMultiplayerGameIntent() const = 0;
 
    virtual void setMultiplayerGame(bool multiplayerGame) = 0;
 
    virtual bool isMultiplayerGame() const = 0;
 
    virtual void setLANBroadcastIntent(bool broadcast) = 0;
 
    virtual bool getLANBroadcastIntent() const = 0;
 
    virtual void setLANBroadcast(bool broadcast) = 0;
 
    virtual bool getLANBroadcast() const = 0;
 
    virtual void setXBLBroadcastIntent(::Social::GamePublishSetting broadcastMode) = 0;
 
    virtual ::Social::GamePublishSetting getXBLBroadcastIntent() const = 0;
 
    virtual bool hasXBLBroadcastIntent() const = 0;
 
    virtual void setXBLBroadcastMode(::Social::GamePublishSetting broadcastMode) = 0;
 
    virtual ::Social::GamePublishSetting getXBLBroadcastMode() const = 0;
 
    virtual bool hasXBLBroadcast() const = 0;
 
    virtual void setPlatformBroadcastIntent(::Social::GamePublishSetting broadcastMode) = 0;
 
    virtual ::Social::GamePublishSetting getPlatformBroadcastIntent() const = 0;
 
    virtual bool hasPlatformBroadcastIntent() const = 0;
 
    virtual void setPlatformBroadcastMode(::Social::GamePublishSetting broadcastMode) = 0;
 
    virtual ::Social::GamePublishSetting getPlatformBroadcastMode() const = 0;
 
    virtual bool hasPlatformBroadcast() const = 0;
 
    virtual void setHasLockedBehaviorPack(bool hasLocked) = 0;
 
    virtual void setHasLockedResourcePack(bool hasLocked) = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::ServerPlayerSleepManager> getServerPlayerSleepManager() = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::ServerPlayerSleepManager const> getServerPlayerSleepManager() const = 0;
 
    virtual void setCommandsEnabled(bool commandsEnabled) = 0;
 
    virtual void setWorldTemplateOptionsUnlocked() = 0;
 
    virtual bool hasLevelStorage() const = 0;
 
    virtual ::LevelStorage& getLevelStorage() = 0;
 
    virtual ::LevelStorage const& getLevelStorage() const = 0;
 
    virtual ::LevelData& getLevelData() = 0;
 
    virtual ::LevelData const& getLevelData() const = 0;
 
    virtual ::PhotoStorage& getPhotoStorage() const = 0;
 
    virtual void createPhotoStorage() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PhotoManager> getPhotoManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PhotoManager const> getPhotoManager() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::EducationSettingsManager> getEducationSettingsManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::EducationSettingsManager const> getEducationSettingsManager() const = 0;
 
    virtual void save() = 0;
 
    virtual void saveLevelData() = 0;
 
    virtual void saveGameData() = 0;
 
    virtual ::std::shared_ptr<void*> requestTimedStorageDeferment() = 0;
 
    virtual ::TickingAreasManager& getTickingAreasMgr() = 0;
 
    virtual void
    addTickingAreaList(::DimensionType dimensionId, ::std::shared_ptr<::TickingAreaList> const& tickingAreas) = 0;
 
    virtual void sendServerLegacyParticle(::ParticleType id, ::Vec3 const& pos, ::Vec3 const& dir, int data) = 0;
 
    virtual void playSound(
        ::SharedTypes::Legacy::LevelSoundEvent type,
        ::Vec3 const&                          pos,
        int                                    data,
        ::ActorSoundIdentifier const&          actorSoundIdentifier,
        bool                                   isGlobal
    ) = 0;
 
    virtual void playSound(
        ::SharedTypes::Legacy::LevelSoundEvent type,
        ::Vec3 const&                          pos,
        float const                            volume,
        float const                            pitch
    ) = 0;
 
    virtual void playSound(::PlaySoundOptions const& options) = 0;
 
    virtual void playSound(
        ::IConstBlockSource const&             region,
        ::SharedTypes::Legacy::LevelSoundEvent type,
        ::Vec3 const&                          pos,
        int                                    data,
        ::ActorSoundIdentifier const&          actorSoundIdentifier,
        bool                                   isGlobal
    ) = 0;
 
    virtual void playSound(
        ::DimensionType                        dimension,
        ::SharedTypes::Legacy::LevelSoundEvent type,
        ::Vec3 const&                          pos,
        int                                    data,
        ::ActorSoundIdentifier const&          actorSoundIdentifier,
        bool                                   isGlobal
    ) = 0;
 
    virtual ::PlayerEventCoordinator& getRemotePlayerEventCoordinator() = 0;
 
    virtual ::ServerPlayerEventCoordinator& getServerPlayerEventCoordinator() = 0;
 
    virtual ::ClientPlayerEventCoordinator& getClientPlayerEventCoordinator() = 0;
 
    virtual ::ActorEventCoordinator& getActorEventCoordinator() = 0;
 
    virtual ::BlockEventCoordinator& getBlockEventCoordinator() = 0;
 
    virtual ::ItemEventCoordinator& getItemEventCoordinator() = 0;
 
    virtual ::ServerNetworkEventCoordinator& getServerNetworkEventCoordinator() = 0;
 
    virtual ::ScriptingEventCoordinator& getScriptingEventCoordinator() = 0;
 
    virtual ::ScriptDeferredEventCoordinator& getScriptDeferredEventCoordinator() = 0;
 
    virtual ::LevelEventCoordinator& getLevelEventCoordinator() = 0;
 
    virtual void handleLevelEvent(::SharedTypes::Legacy::LevelEvent type, ::Vec3 const& pos, int data) = 0;
 
    virtual void handleLevelEvent(::SharedTypes::Legacy::LevelEvent type, ::CompoundTag const& data) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelEventManager> getLevelEventManager() = 0;
 
    virtual void handleStopSoundEvent(::std::string const& name) = 0;
 
    virtual void handleStopAllSounds() = 0;
 
    virtual void handleStopMusicEvent() = 0;
 
    virtual void broadcastLevelEvent(
        ::SharedTypes::Legacy::LevelEvent      type,
        ::Vec3 const&                          pos,
        int                                    data,
        ::UserEntityIdentifierComponent const* userIdentifier
    ) = 0;
 
    virtual void broadcastLevelEvent(
        ::SharedTypes::Legacy::LevelEvent      type,
        ::CompoundTag const&                   tag,
        ::UserEntityIdentifierComponent const* userIdentifier
    ) = 0;
 
    virtual void
    broadcastLocalEvent(::BlockSource& region, ::SharedTypes::Legacy::LevelEvent type, ::Vec3 const& pos, int data) = 0;
 
    virtual void broadcastLocalEvent(
        ::BlockSource&                    region,
        ::SharedTypes::Legacy::LevelEvent type,
        ::Vec3 const&                     pos,
        ::Block const&                    block
    ) = 0;
 
    virtual void broadcastSoundEvent(
        ::BlockSource&                         region,
        ::SharedTypes::Legacy::LevelSoundEvent type,
        ::Vec3 const&                          pos,
        ::Block const&                         block,
        ::ActorSoundIdentifier const&          actorSoundIdentifier,
        bool                                   isGlobal,
        ::std::optional<::Vec3> const&         fireAtPosition
    ) = 0;
 
    virtual void broadcastSoundEvent(
        ::BlockSource&                         region,
        ::SharedTypes::Legacy::LevelSoundEvent type,
        ::Vec3 const&                          pos,
        int                                    data,
        ::ActorSoundIdentifier const&          actorSoundIdentifier,
        bool                                   isGlobal,
        ::std::optional<::Vec3> const&         fireAtPosition
    ) = 0;
 
    virtual void broadcastSoundEvent(
        ::Dimension&                           dimension,
        ::SharedTypes::Legacy::LevelSoundEvent type,
        ::Vec3 const&                          pos,
        int                                    data,
        ::ActorSoundIdentifier const&          actorSoundIdentifier,
        bool                                   isGlobal,
        ::std::optional<::Vec3> const&         fireAtPosition
    ) = 0;
 
    virtual void broadcastActorEvent(
        ::Actor&                       actor,
        ::ActorEvent                   eventId,
        int                            data,
        ::std::optional<::Vec3> const& fireAtPosition
    ) const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::ActorEventBroadcaster const> getActorEventBroadcaster() const = 0;
 
    virtual void addChunkViewTracker(::std::weak_ptr<::ChunkViewSource> chunkViewSource) = 0;
 
    virtual void onChunkReload(::Bounds const& bound) = 0;
 
    virtual void onChunkReloaded(::ChunkSource& source, ::LevelChunk& lc) = 0;
 
    virtual int getActivePlayerCount() const = 0;
 
    virtual int getActiveUsersCount() const = 0;
 
    virtual void forEachPlayer(::std::function<bool(::Player&)> callback) = 0;
 
    virtual void forEachPlayer(::std::function<bool(::Player const&)> callback) const = 0;
 
    virtual void forEachUser(::std::function<bool(::EntityContext&)> callback) = 0;
 
    virtual void forEachUser(::std::function<bool(::EntityContext const&)> callback) const = 0;
 
    virtual ::Player* findPlayer(::std::function<bool(::Player const&)> pred) const = 0;
 
    virtual ::Player* findPlayer(::std::function<bool(::WeakEntityRef const&)> pred) const = 0;
 
    virtual int getUserCount() const = 0;
 
    virtual int countUsersWithMatchingNetworkId(::NetworkIdentifier const& networkId) const = 0;
 
    virtual ::std::vector<::OwnerPtr<::EntityContext>> const& getUsers() const = 0;
 
    virtual ::std::vector<::OwnerPtr<::EntityContext>> const& getEntities() const = 0;
 
    virtual void onSubChunkLoaded(
        ::ChunkSource& source,
        ::LevelChunk&  lc,
        short          absoluteSubChunkIndex,
        bool           subChunkVisibilityChanged
    ) = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::SubChunkManager> getSubChunkManager() = 0;
 
    virtual void onChunkLoaded(::ChunkSource& source, ::LevelChunk& lc) = 0;
 
    virtual void onChunkDiscarded(::LevelChunk& lc) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelChunkEventManager> getLevelChunkEventManager() = 0;
 
    virtual ::LevelChunkMetaDataManager* getLevelChunkMetaDataManager() = 0;
 
    virtual void queueEntityDestruction(::OwnerPtr<::EntityContext> entity) = 0;
 
    virtual ::OwnerPtr<::EntityContext> removeEntity(::Actor& actor) = 0;
 
    virtual ::OwnerPtr<::EntityContext> removeEntity(::WeakEntityRef entityRef) = 0;
 
    virtual void forceRemoveEntity(::Actor& actor) = 0;
 
    virtual void forceRemoveEntityfromWorld(::Actor& actor) = 0;
 
    virtual void forceFlushRemovedPlayers() = 0;
 
    virtual void loadFunctionManager() = 0;
 
    virtual void levelCleanupQueueEntityRemoval(::OwnerPtr<::EntityContext> entity) = 0;
 
    virtual void registerTemporaryPointer(::_TickPtr& ptr) = 0;
 
    virtual void unregisterTemporaryPointer(::_TickPtr& ptr) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::TempEPtrManager> getTempEPtrManager() = 0;
 
    virtual bool destroyBlock(
        ::BlockSource&              region,
        ::BlockPos const&           pos,
        bool                        dropResources,
        ::BlockChangeContext const& changeSourceContext,
        ::BlockDestroySound         destroySound
    ) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelBlockDestroyer> getLevelBlockDestroyer() = 0;
 
    virtual void upgradeStorageVersion(::StorageVersion v) = 0;
 
    virtual void suspendAndSave() = 0;
 
    virtual ::Particle* addParticle(
        ::ParticleType       id,
        ::Vec3 const&        pos,
        ::Vec3 const&        dir,
        int                  data,
        ::CompoundTag const* tag,
        bool                 isGlobal
    ) = 0;
 
    virtual void addParticleEffect(
        ::HashedString const&      effect,
        ::Vec3 const&              emitterPosition,
        ::MolangVariableMap const& molangVariables
    ) = 0;
 
    virtual void addTerrainParticleEffect(
        ::BlockPos const& pos,
        ::Block const&    block,
        ::Vec3 const&     emitterPosition,
        float             intensity,
        float             velocityScalar,
        float             emitterRadius
    ) = 0;
 
    virtual void addTerrainSlideEffect(
        ::BlockPos const& pos,
        ::Block const&    block,
        ::Vec3 const&     emitterPosition,
        float             intensity,
        float             velocityScalar,
        float             emitterRadius
    ) = 0;
 
    virtual void addBreakingItemParticleEffect(
        ::Vec3 const&                     pos,
        ::BreakingItemParticleData const& data,
        ::ResolvedItemIconInfo const&     textureInfo
    ) = 0;
 
    virtual void addBiomeTintedParticleEffect(
        ::HashedString const&         effect,
        ::BlockPos const&             pos,
        ::Block const&                block,
        ::std::optional<::mce::Color> overrideColor
    ) = 0;
 
    virtual ::ActorUniqueID getNewUniqueID() = 0;
 
    virtual ::ActorRuntimeID getNextRuntimeID() = 0;
 
    virtual ::std::vector<::ChunkPos> const& getTickingOffsets() const = 0;
 
    virtual ::std::vector<::ChunkPos> const& getClientTickingOffsets() const = 0;
 
    virtual ::std::vector<::ChunkPos>
    getSortedPositionsFromClientOffsets(::std::vector<::ChunkPos> const& centers) const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::ChunkTickOffsetManager const> getChunkTickOffsetManager() const = 0;
 
    virtual bool isExporting() const = 0;
 
    virtual void setIsExporting(bool IsExporting) = 0;
 
    virtual ::SavedDataStorage& getSavedData() = 0;
 
    virtual ::MapItemSavedData* getMapSavedData(::ActorUniqueID const uuid) = 0;
 
    virtual ::MapItemSavedData* getMapSavedData(::CompoundTag const& instance) = 0;
 
    virtual ::MapItemSavedData* getMapSavedData(::CompoundTag const* instance) = 0;
 
    virtual void requestMapInfo(::ActorUniqueID const uuid, bool forceUpdate) = 0;
 
    virtual ::ActorUniqueID expandMapByID(::ActorUniqueID const uuid, bool wasInit) = 0;
 
    virtual bool copyAndLockMap(::ActorUniqueID const originalMapUuid, ::ActorUniqueID const newMapUuid) = 0;
 
    virtual ::MapItemSavedData& createMapSavedData(
        ::ActorUniqueID const& uuid,
        ::BlockPos const&      origin,
        ::DimensionType        dimension,
        int                    returnScaleLevel
    ) = 0;
 
    virtual ::MapItemSavedData& createMapSavedData(
        ::std::vector<::ActorUniqueID> const& mapIds,
        ::BlockPos const&                     origin,
        ::DimensionType                       dimension,
        int                                   returnScaleLevel
    ) = 0;
 
    virtual ::Core::PathBuffer<::std::string> getScreenshotsFolder() const = 0;
 
    virtual ::std::string getLevelId() const = 0;
 
    virtual void setLevelId(::std::string LevelId) = 0;
 
    virtual ::TaskGroup& getSyncTasksGroup() = 0;
 
    virtual ::TaskGroup& getIOTasksGroup() = 0;
 
    virtual ::ResourcePackManager* getClientResourcePackManager() const = 0;
 
    virtual ::ResourcePackManager* getServerResourcePackManager() const = 0;
 
    virtual ::TradeTables* getTradeTables();
 
    virtual void decrementTagCache(
        ::std::string const&                                                      tag,
        ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& tagRegistry
    ) = 0;
 
    virtual void incrementTagCache(
        ::std::string const&                                                      tag,
        ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& tagRegistry
    ) = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::TagCacheManager> getTagCacheManager() = 0;
 
    virtual bool isEdu() const = 0;
 
    virtual ::ActorFactory& getActorFactory() = 0;
 
    virtual ::ActorFactory const& getActorFactory() const = 0;
 
    virtual ::ActorInfoRegistry* getActorInfoRegistry() = 0;
 
    virtual ::StackRefResult<::EntityRegistry> getEntityRegistry() = 0;
 
    virtual ::StackRefResult<::EntityRegistry const> getEntityRegistry() const = 0;
 
    virtual ::gsl::not_null<::StackRefResult<::IContainerRegistryAccess>> getContainerRegistryAccess() const = 0;
 
    virtual ::gsl::not_null<::StackRefResult<::IContainerRegistryTracker>> getContainerRegistryTracker() const = 0;
 
    virtual ::gsl::not_null<::StackRefResult<::IDynamicContainerSerialization>>
    getDynamicContainerSerialization() const = 0;
 
    virtual ::EntitySystems& getEntitySystems() = 0;
 
    virtual ::WeakRef<::EntityContext> getLevelEntity() = 0;
 
    virtual ::WeakRef<::EntityContext const> getLevelEntity() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::VolumeEntityManagerServer> tryGetVolumeEntityManagerServer() const = 0;
 
    virtual void runCommand(
        ::HashedString const&     commandStr,
        ::CommandOrigin&          origin,
        ::CommandOriginSystem     originSystem,
        ::CurrentCmdVersion const commandVersion
    ) = 0;
 
    virtual void runCommand(::Command& command, ::CommandOrigin& origin, ::CommandOriginSystem originSystem) = 0;
 
    virtual ::PlayerCapabilities::ISharedController const& getCapabilities() const = 0;
 
    virtual ::TagRegistry<::IDType<::LevelTagIDType>, ::IDType<::LevelTagSetIDType>>& getTagRegistry() = 0;
 
    virtual ::PlayerMovementSettings const& getPlayerMovementSettings() const = 0;
 
    virtual void setPlayerMovementSettings(::PlayerMovementSettings const& settings) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerMovementSettingsManager> getPlayerMovementSettingsManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerMovementSettingsManager const>
    getPlayerMovementSettingsManager() const = 0;
 
    virtual bool canUseSkin(
        ::SerializedSkinRef const& skin,
        ::NetworkIdentifier const& networkIdentifier,
        ::ActorUniqueID const&     playerId
    ) const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::TrustedSkinHelper const> getTrustedSkinHelper() const = 0;
 
    virtual ::PositionTrackingDB::PositionTrackingDBClient* getPositionTrackerDBClient() const = 0;
 
    virtual ::PositionTrackingDB::PositionTrackingDBServer* getPositionTrackerDBServer() const = 0;
 
    virtual void flushRunTimeLighting() = 0;
 
    virtual ::std::weak_ptr<::ISubChunkLighter> getSubChunkLighter() const = 0;
 
    virtual void loadBlockDefinitionGroup(::Experiments const& experiments) = 0;
 
    virtual void initializeBlockDefinitionGroup() = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::IUnknownBlockTypeRegistry> getUnknownBlockTypeRegistry() = 0;
 
    virtual bool isClientSide() const = 0;
 
    virtual ::SubClientId getSubClientId() const = 0;
 
    virtual ::std::unordered_map<::mce::UUID, ::PlayerListEntry> const& getPlayerList() const = 0;
 
    virtual ::std::string const& getPlayerXUID(::mce::UUID const& uuid) const = 0;
 
    virtual ::std::string const& getPlayerPlatformOnlineId(::mce::UUID const& uuid) const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerListManager> getPlayerListManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerListManager const> getPlayerListManager() const = 0;
 
    virtual ::std::vector<::WeakEntityRef> const& getActiveUsers() const = 0;
 
    virtual ::std::vector<::Actor*> getRuntimeActorList() const = 0;
 
    virtual void notifySubChunkRequestManager(::SubChunkPacket const& packet) = 0;
 
    virtual ::SubChunkRequestManager* getSubChunkRequestManager() = 0;
 
    virtual ::PacketSender* getPacketSender() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::NetEventCallback> getNetEventCallback() const = 0;
 
    virtual void setNetEventCallback(::Bedrock::NonOwnerPointer<::NetEventCallback> val) = 0;
 
    virtual ::gsl::not_null<::StackRefResult<::ILevelRandom>> getILevelRandom() = 0;
 
    virtual ::IRandom& getIRandom() const = 0;
 
    virtual ::Random& getRandom() const = 0;
 
    virtual ::Random& getThreadRandom() const = 0;
 
    virtual ::HitResult& getHitResult() = 0;
 
    virtual ::HitResult& getLiquidHitResult() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::HitResultWrapper> getHitResultWrapper() = 0;
 
    virtual ::std::string const& getImmersiveReaderString() const = 0;
 
    virtual void setImmersiveReaderString(::std::string newString) = 0;
 
    virtual ::AdventureSettings& getAdventureSettings() = 0;
 
    virtual ::AdventureSettings const& getAdventureSettings() const = 0;
 
    virtual ::GameRules const& getGameRules() const = 0;
 
    virtual ::GameRules& getGameRules() = 0;
 
    virtual bool hasStartWithMapEnabled() const = 0;
 
    virtual bool isEditorWorld() const = 0;
 
    virtual bool isEditorTestWorld() const = 0;
 
    virtual bool getAllowAnonymousBlockDropsInEditorWorlds() const = 0;
 
    virtual bool isHardcore() const = 0;
 
    virtual ::Abilities& getDefaultAbilities() = 0;
 
    virtual ::PermissionsHandler& getDefaultPermissions() = 0;
 
    virtual ::PermissionsHandler const& getDefaultPermissions() const = 0;
 
    virtual bool getTearingDown() const = 0;
 
    virtual void takePicture(
        ::cg::ImageBuffer&                                              outImage,
        ::Actor*                                                        camera,
        ::Actor*                                                        target,
        ::ScreenshotOptions&                                            screenshotOptions,
        ::std::function<void(::cg::ImageBuffer&, ::ScreenshotOptions&)> completedScreenshotCallback
    ) = 0;
 
    virtual ::LevelSoundManager& getLevelSoundManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::SoundPlayerInterface> getSoundPlayer() const = 0;
 
    virtual void setSimPaused(bool value) = 0;
 
    virtual bool getSimPaused() const = 0;
 
    virtual void setFinishedInitializing() = 0;
 
    virtual ::LootTables& getLootTables() = 0;
 
    virtual void updateWeather(float rainLevel, int rainTime, float lightningLevel, int lightningTime) = 0;
 
    virtual int getNetherScale() const = 0;
 
    virtual ::Scoreboard& getScoreboard() = 0;
 
    virtual ::Scoreboard const& getScoreboard() const = 0;
 
    virtual ::Scoreboard* tryGetScoreboard() = 0;
 
    virtual ::LayeredAbilities* getPlayerAbilities(::ActorUniqueID const& playerId) = 0;
 
    virtual void setPlayerAbilities(::ActorUniqueID const& playerId, ::LayeredAbilities const& abilities) = 0;
 
    virtual void sendAllPlayerAbilities(::Player const& playerReference) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerAbilitiesManager> getPlayerAbilitiesManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerPermissionsManager> getPlayerPermissionsManager() = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::PlayerPermissionsSynchroniser> getPlayerPermissionsSynchroniser() = 0;
 
    virtual ::MolangPackSettingsCache const* getMolangPackSettingsCache() const = 0;
 
    virtual ::Recipes& getRecipes() const = 0;
 
    virtual ::BlockReducer* getBlockReducer() const = 0;
 
    virtual ::std::weak_ptr<::TrimPatternRegistry const> getTrimPatternRegistry() const = 0;
 
    virtual ::std::weak_ptr<::TrimPatternRegistry> getTrimPatternRegistry() = 0;
 
    virtual ::std::weak_ptr<::TrimMaterialRegistry const> getTrimMaterialRegistry() const = 0;
 
    virtual ::std::weak_ptr<::TrimMaterialRegistry> getTrimMaterialRegistry() = 0;
 
    virtual ::BlockType const& getRegisteredBorderBlock() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::LevelChunkPerformanceTelemetry> getLevelChunkPerformanceTelemetry() = 0;
 
    virtual bool use3DBiomeMaps() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::ChunkGenerationManager> getChunkGenerationManager() = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::ChunkGenerationManager const> getChunkGenerationManager() const = 0;
 
    virtual void clearAllGenerationRequests(::NetworkIdentifier const& player, ::SubClientId clientId) = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::MapDataManager> getMapDataManager() = 0;
 
    virtual ::Level* asLevel();
 
    virtual ::ClientLevel* asClientLevel();
 
    virtual ::Bedrock::NonOwnerPointer<::CameraRegistry const> getCameraRegistry() const = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::CameraRegistry> getCameraRegistry() = 0;
 
    virtual ::Bedrock::NonOwnerPointer<::EntitySystems> getCameraSystems() = 0;
 
    virtual bool isClientSideGenerationEnabled() = 0;
 
    virtual bool blockNetworkIdsAreHashes() = 0;
 
    virtual ::ItemRegistryRef getItemRegistry() const = 0;
 
    virtual ::Bedrock::NotNullNonOwnerPtr<::BlockTypeRegistry> getBlockTypeRegistry() const = 0;
 
    virtual void pauseAndFlushTaskGroups() = 0;
 
    virtual ::cereal::ReflectionCtx& cerealContext() = 0;
 
    virtual ::cereal::ReflectionCtx const& cerealContext() const = 0;
 
    virtual void subChunkTickAndSendRequests() = 0;
 
    virtual void digestServerBlockProperties(::StartGamePacket const& packet) = 0;
 
    virtual ::PlayerDeathManager* _getPlayerDeathManager() = 0;
 
    virtual ::MapDataManager& _getMapDataManager() = 0;
 
    virtual ::TickTimeManager const& _getTickTimeManager() const = 0;
 
    virtual ::TickTimeManager& _getTickTimeManager() = 0;
 
    virtual ::cereal::ReflectionCtx& _cerealContext() = 0;
 
    virtual void _onLowMemory() = 0;
    // NOLINTEND
 
public:
    // member functions
    // NOLINTBEGIN
    MCAPI void addParticleEffect(::HashedString const& effect, ::Vec3 const& emitterPosition);
    // NOLINTEND
 
public:
    // virtual function thunks
    // NOLINTBEGIN
    MCNAPI ::ClientLevel* $asClientLevel();
 
 
    // NOLINTEND
};