typesforbukkit/1.17/org/bukkit/Bukkit.ts

Types For Bukkit

// API Link: https://tfb.neocities.org/1.17/org/bukkit/Bukkit

namespace org.bukkit {
	/** @description Represents the Bukkit core, for version and Server singleton handling */
	export class Bukkit {

		/** @description Adds a recipe to the crafting manager */
		static addRecipe(recipe: org.bukkit.inventory.Recipe) : boolean {return;}

		/** @description Get an iterator through all advancements */
		static advancementIterator() : java.util.Iterator<org.bukkit.advancement.Advancement> {return;}

		/** @description Bans the specified address from the server */
		static banIP(address: String) : void {}

		/** @description Broadcasts the specified message to every user with the given permission name */
		static broadcast(message: String, permission: String) : int {return;}

		/** @description Broadcast a message to all players */
		static broadcastMessage(message: String) : int {return;}

		/** @description Clears the list of crafting recipes */
		static clearRecipes() : void {}

		/** @description Creates a new BlockData instance with material and properties parsed from provided data */
		static createBlockData(data: String) : org.bukkit.block.data.BlockData;
		/** @description Creates a new BlockData instance for the specified Material, with all properties initialized to unspecified defaults */
		static createBlockData(material: org.bukkit.Material) : org.bukkit.block.data.BlockData;
		/** @description Creates a new BlockData instance for the specified Material, with all properties initialized to unspecified defaults, except for those provided in data */
		static createBlockData(material: org.bukkit.Material, data: String) : org.bukkit.block.data.BlockData;
		/** @description Creates a new BlockData instance for the specified Material, with all properties initialized to unspecified defaults */
		static createBlockData(material: String, consumer: org.bukkit.util.Consumer<org.bukkit.block.data.BlockData>) : org.bukkit.block.data.BlockData;
        static createBlockData(material?: any, data?: any, consumer?: any) : any {return;};

		/** @description Creates a boss bar instance to display to players */
		static createBossBar(title: String, color: org.bukkit.boss.BarColor, style: org.bukkit.boss.BarStyle, ...flags: org.bukkit.boss.BarFlag[]) : org.bukkit.boss.BossBar;
		/** @description Creates a boss bar instance to display to players */
		static createBossBar(key: org.bukkit.NamespacedKey, title: String, color: org.bukkit.boss.BarColor, style: org.bukkit.boss.BarStyle, ...flags: org.bukkit.boss.BarFlag[]) : org.bukkit.boss.KeyedBossBar;
        static createBossBar(title: any, color: any, style: any, key?: any, ...flags: org.bukkit.boss.BarFlag[]) : any {return;}

		/** @description Create a ChunkData for use in a generator */
		static createChunkData(world: org.bukkit.World) : org.bukkit.generator.ChunkGenerator_$_ChunkData {return;}

		/** @description Create a new explorer map targeting the closest nearby structure of a given StructureType */
		static createExplorerMap(world: org.bukkit.World, location: org.bukkit.World, structureType: org.bukkit.StructureType) : org.bukkit.inventory.ItemStack;
		/** @description Create a new explorer map targeting the closest nearby structure of a given StructureType */
		static createExplorerMap(world: org.bukkit.World, location: org.bukkit.World, structureType: org.bukkit.StructureType, radius: int, findUnexplored: boolean) : org.bukkit.inventory.ItemStack;
        static createExplorerMap(world: any, location: any, structureType: any, radius?: any, findUnexplored?: any) : any {return;}

		/** @description Creates an empty inventory of type InventoryType.CHEST with the specified size */
		static createInventory(owner: org.bukkit.inventory.InventoryHolder, size: int) : org.bukkit.inventory.Inventory;
		/** @description Creates an empty inventory of type InventoryType.CHEST with the specified size and title */
		static createInventory(owner: org.bukkit.inventory.InventoryHolder, size: int, title: String) : org.bukkit.inventory.Inventory;
		/** @description Creates an empty inventory with the specified type */
		static createInventory(owner: org.bukkit.inventory.InventoryHolder, type: org.bukkit.event.inventory.InventoryType) : org.bukkit.inventory.Inventory;
		/** @description Creates an empty inventory with the specified type and title */
		static createInventory(owner: org.bukkit.inventory.InventoryHolder, type: org.bukkit.event.inventory.InventoryType, title: String) : org.bukkit.inventory.Inventory;
        static createInventory(owner: any, size?: any, type?: any, title?: any) : any {return;}

		/** @description Create a new map with an automatically assigned ID */
		static createMap(world: org.bukkit.World) : org.bukkit.map.MapView {return;}

		/** @description Creates an empty merchant */
		static createMerchant(title: String) : org.bukkit.inventory.Merchant {return;}

		/** @description Creates or loads a world with the given name using the specified options */
		static createWorld(creator: org.bukkit.WorldCreator) : org.bukkit.World {return;}

		/** @description Dispatches a command on this server, and executes it if found */
		static dispatchCommand(sender: org.bukkit.command.CommandSender, commandLine: String) : boolean {return;}

		/** @description Get the advancement specified by this key */
		static getAdvancement(key: org.bukkit.NamespacedKey) : org.bukkit.advancement.Advancement {return;}

		/** @description Gets whether this server allows the End or not */
		static getAllowEnd() : boolean {return;}

		/** @description Gets whether this server allows flying or not */
		static getAllowFlight() : boolean {return;}

		/** @description Gets whether this server allows the Nether or not */
		static getAllowNether() : boolean {return;}

		/** @description Gets user-specified limit for number of ambient mobs that can spawn in a chunk */
		static getAmbientSpawnLimit() : int {return;}

		/** @description Gets user-specified limit for number of animals that can spawn in a chunk */
		static getAnimalSpawnLimit() : int {return;}

		/** @description Gets a ban list for the supplied type */
		static getBanList(type: org.bukkit.BanList_$_Type) : org.bukkit.BanList {return;}

		/** @description Gets a set containing all banned players */
		static getBannedPlayers() : java.util.Set<org.bukkit.OfflinePlayer> {return;}

		/** @description Gets the KeyedBossBar specified by this key */
		static getBossBar(key: org.bukkit.NamespacedKey) : org.bukkit.boss.KeyedBossBar {return;}

		/** @description Gets an unmodifiable iterator through all persistent bossbars */
		static getBossBars() : java.util.Iterator<org.bukkit.boss.KeyedBossBar> {return;}

		/** @description Gets the Bukkit version that this server is running */
		static getBukkitVersion() : String {return;}

		/** @description Gets a list of command aliases defined in the server properties */
		static getCommandAliases() : java.util.Map<String,String[]> {return;}

		/** @description Gets the value of the connection throttle setting */
		static getConnectionThrottle() : long {return;}

		/** @description Gets a ConsoleCommandSender that may be used as an input source for this server */
		static getConsoleSender() : org.bukkit.command.ConsoleCommandSender {return;}

		/** @description Gets the default GameMode for new players */
		static getDefaultGameMode() : org.bukkit.GameMode {return;}

		/** @description Gets an entity on the server by its UUID */
		static getEntity(uuid: java.util.UUID) : org.bukkit.entity.Entity {return;}

		/** @description Get generate-structures setting */
		static getGenerateStructures() : boolean {return;}

		/** @description Gets the HelpMap providing help topics for this server */
		static getHelpMap() : org.bukkit.help.HelpMap {return;}

		/** @description Gets the idle kick timeout */
		static getIdleTimeout() : int {return;}

		/** @description Get the IP that this server is bound to, or empty string if not specified */
		static getIp() : String {return;}

		/** @description Gets a set containing all current IPs that are banned */
		static getIPBans() : java.util.Set<String> {return;}

		/** @description Gets the instance of the item factory (for ItemMeta) */
		static getItemFactory() : org.bukkit.inventory.ItemFactory {return;}

		/** @description Returns the primary logger associated with this server instance */
		static getLogger() : java.util.logging.Logger {return;}

		/** @description Gets the specified LootTable */
		static getLootTable(key: org.bukkit.NamespacedKey) : org.bukkit.loot.LootTable {return;}

		/** @deprecated Magic value */
		static getMap(id: int) : org.bukkit.map.MapView {return;}

		/** @description Get the maximum amount of players which can login to this server */
		static getMaxPlayers() : int {return;}

		/** @description Get max world size */
		static getMaxWorldSize() : int {return;}

		/** @description Gets the Messenger responsible for this server */
		static getMessenger() : org.bukkit.plugin.messaging.Messenger {return;}

		/** @description Gets user-specified limit for number of monsters that can spawn in a chunk */
		static getMonsterSpawnLimit() : int {return;}

		/** @description Gets the message that is displayed on the server list */
		static getMotd() : String {return;}

		/** @description Gets the name of this server implementation */
		static getName() : String {return;}

		/** @deprecated Persistent storage of users should be by UUID as names are no longer unique past a single session */
		static getOfflinePlayer(name: String) : org.bukkit.OfflinePlayer;
		/** @description Gets the player by the given UUID, regardless if they are offline or online */
		static getOfflinePlayer(id: java.util.UUID) : org.bukkit.OfflinePlayer;
		static getOfflinePlayer(name?: any, id?: any) : any {return;}

		/** @description Gets every player that has ever played on this server */
		static getOfflinePlayers() : java.util.Collection<org.bukkit.OfflinePlayer> {return;}

		/** @description Gets whether the Server is in online mode or not */
		static getOnlineMode() : boolean {return;}

		/** @description Gets a view of all currently logged in players. generic return type should extend org.bukkit.entity.Player */
		static getOnlinePlayers() : java.util.Collection<any> {return;}

		/** @description Gets a set containing all player operators */
		static getOperators() : java.util.Set<org.bukkit.OfflinePlayer> {return;}

		/** @description Gets a player object by the given username */
		static getPlayer(name: String) : org.bukkit.entity.Player;
		/** @description Gets the player with the given UUID */
		static getPlayer(id: java.util.UUID) : org.bukkit.entity.Player;
		static getPlayer(name?: any, id?: any) : any {return;}
	
		/** @description Gets the player with the exact given name, case insensitive */
		static getPlayerExact(name: String) : org.bukkit.entity.Player {return;}

		/** @description Gets a PluginCommand with the given name or alias */
		static getPluginCommand(name: String) : org.bukkit.command.PluginCommand {return;}

		/** @description Gets the plugin manager for interfacing with plugins */
		static getPluginManager() : org.bukkit.plugin.PluginManager {return;}

		/** @description Get the game port that the server runs on */
		static getPort() : int {return;}

		/** @description Get the Recipe for the given key */
		static getRecipe(recipeKey: org.bukkit.NamespacedKey) : org.bukkit.inventory.Recipe {return;}

		/** @description Get a list of all recipes for a given item */
		static getRecipesFor(result: org.bukkit.inventory.ItemStack) : java.util.List<org.bukkit.inventory.Recipe> {return;}

		/** @description Gets the scheduler for managing scheduled events */
		static getScheduler() : org.bukkit.scheduler.BukkitScheduler {return;}

		/** @description Gets the instance of the scoreboard manager */
		static getScoreboardManager() : org.bukkit.scoreboard.ScoreboardManager {return;}

		/** @description Gets the current Server singleton */
		static getServer() : org.bukkit.Server {return;}

		/** @description Gets an instance of the server's default server-icon */
		static getServerIcon() : org.bukkit.util.CachedServerIcon {return;}

		/** @description Gets a services manager */
		static getServicesManager() : org.bukkit.plugin.ServicesManager {return;}

		/** @description Gets the default message that is displayed when the server is stopped */
		static getShutdownMessage() : String {return;}

		/** @description Gets the radius, in blocks, around each worlds spawn point to protect */
		static getSpawnRadius() : int {return;}

		/** @description Gets a tag which has already been defined within the server */
		static getTag<T extends org.bukkit.Keyed>(registry: String, tag: org.bukkit.NamespacedKey, clazz: java.lang.Class<T>) : org.bukkit.Tag<T> {return;}

		/** @description Gets a all tags which have been defined within the server */
		static getTags<T extends org.bukkit.Keyed>(registry: String, clazz: java.lang.Class<T>) : java.lang.Iterable<org.bukkit.Tag<T>> {return;}

		/** @description Gets the default ticks per ambient mob spawns value */
		static getTicksPerAmbientSpawns() : int {return;}

		/** @description Gets default ticks per animal spawns value */
		static getTicksPerAnimalSpawns() : int {return;}

		/** @description Gets the default ticks per monster spawns value */
		static getTicksPerMonsterSpawns() : int {return;}

		/** @description Gets the default ticks per water ambient mob spawns value */
		static getTicksPerWaterAmbientSpawns() : int {return;}

		/** @description Gets the default ticks per water mob spawns value */
		static getTicksPerWaterSpawns() : int {return;}

		/** @deprecated */
		static getUnsafe() : org.bukkit.UnsafeValues {return;}

		/** @description Gets the name of the update folder */
		static getUpdateFolder() : String {return;}

		/** @description Gets the update folder */
		static getUpdateFolderFile() : java.io.File {return;}

		/** @description Gets the version string of this server implementation */
		static getVersion() : String {return;}

		/** @description Get the view distance from this server */
		static getViewDistance() : int {return;}

		/** @description Gets the current warning state for the server */
		static getWarningState() : org.bukkit.Warning_$_WarningState {return;}

		/** @description Gets user-specified limit for number of water ambient mobs that can spawn in a chunk */
		static getWaterAmbientSpawnLimit() : int {return;}

		/** @description Gets user-specified limit for number of water animals that can spawn in a chunk */
		static getWaterAnimalSpawnLimit() : int {return;}

		/** @description Gets a list of whitelisted players */
		static getWhitelistedPlayers() : java.util.Set<org.bukkit.OfflinePlayer> {return;}

		/** @description Gets the world with the given name */
		static getWorld(name: String) : org.bukkit.World;
		/** @description Gets the world from the given Unique ID */
		static getWorld(uid: java.util.UUID) : org.bukkit.World;
		static getWorld(name?: any, uid?: any) : any {return;}

		/** @description Gets the folder that contains all of the various Worlds */
		static getWorldContainer() : java.io.File {return;}

		/** @description Gets a list of all worlds on this server */
		static getWorlds() : java.util.List<org.bukkit.World> {return;}

		/** @description Get world type (level-type setting) for default world */
		static getWorldType() : String {return;}

		/** @description Gets whether this server has a whitelist or not */
		static hasWhitelist() : boolean {return;}

		/** @description Gets whether the server is in hardcore mode or not */
		static isHardcore() : boolean {return;}

		/** @description Checks the current thread against the expected primary thread for the server */
		static isPrimaryThread() : boolean {return;}

        /** @description Gets whether the server whitelist is enforced */
		static isWhitelistEnforced() : boolean {return;}

		/** @description Creates a cached server-icon for the specific image */
		static loadServerIcon(image: java.awt.image.BufferedImage) : org.bukkit.util.CachedServerIcon;
		/** @description Loads an image from a file, and returns a cached image for the specific server-icon */
		static loadServerIcon(file: java.io.File) : org.bukkit.util.CachedServerIcon;
		static loadServerIcon(image?: any, file?: any) : any {return;}

		/** @description Attempts to match any players with the given name, and returns a list of all possibly matches */
		static matchPlayer(name: String) : java.util.List<org.bukkit.entity.Player> {return;}

		/** @description Get an iterator through the list of crafting recipes */
		static recipeIterator() : java.util.Iterator<org.bukkit.inventory.Recipe> {return;}

		/** @description Reloads the server, refreshing settings and plugin information */
		static reload() : void {}

		/** @description Reload only the Minecraft data for the server */
		static reloadData() : void {}

		/** @description Reloads the whitelist from disk */
		static reloadWhitelist() : void {}

		/** @description Removes a KeyedBossBar specified by this key */
		static removeBossBar(key: org.bukkit.NamespacedKey) : boolean {return;}

		/** @description Remove a recipe from the server */
		static removeRecipe(key: org.bukkit.NamespacedKey) : boolean {return;}

		/** @description Resets the list of crafting recipes to the default */
		static resetRecipes() : void {}

		/** @description Writes loaded players to disk */
		static savePlayers() : void {}

		/** @description Selects entities using the given Vanilla selector */
		static selectEntities(sender: org.bukkit.command.CommandSender, selector: String) : java.util.List<org.bukkit.entity.Entity> {return;}

		/** @description Sets the default GameMode for new players */
		static setDefaultGameMode(mode: org.bukkit.GameMode) : void {}

		/** @description Set the idle kick timeout */
		static setIdleTimeout(threshold: int) : void {}

		/** @description Attempts to set the Server singleton */
		static setServer(server: org.bukkit.Server) : void {}

		/** @description Sets the radius, in blocks, around each worlds spawn point to protect */
		static setSpawnRadius(value: int) : void {}

		/** @description Sets if the server is whitelisted */
		static setWhitelist(value: boolean) : void {}

		/** @description Shutdowns the server, stopping everything */
		static shutdown() : void {}

		/** @description TODO: Implement Spigot version class */
		static spigot() : any {return;}

		/** @description Unbans the specified address from the server */
		static unbanIP(address: String) : void {}

		/** @description Unloads a world with the given name */
		static unloadWorld(name: String, save: boolean) : boolean;
		/** @description Unloads the given world */
		static unloadWorld(world: org.bukkit.World, save: boolean) : boolean;
		static unloadWorld(save: any, name?: any, world?: any) : any {return;}

	}
}