export interface BanEntry {
    target: string;
    expiration: Date;
    source: string;
    created: Date;
    reason: string;
}

export interface BanList {
    banEntries: BanEntry[];
}

export interface BlockChangeDelegate {
    height: number;
}

export interface Bukkit {
}

export interface Chunk {
    loaded: boolean;
    world: World;
    x: number;
    z: number;
    chunkSnapshot: ChunkSnapshot;
    entities: Entity[];
    tileEntities: BlockState[];
}

export interface ChunkSnapshot {
    x: number;
    z: number;
    worldName: string;
    captureFullTime: number;
}

export interface FireworkEffect extends ConfigurationSerializable {
    colors: any[];
    fadeColors: any[];
    type: any;
}

export interface Builder {
}

export interface Location extends Cloneable, ConfigurationSerializable {
    world: World;
    x: number;
    y: number;
    z: number;
    pitch: number;
    yaw: number;
    block: Block;
    blockZ: number;
    direction: Vector;
    blockY: number;
    blockX: number;
    chunk: Chunk;
}

export interface Note {
    id: number;
    tone: Tone;
    octave: number;
    sharped: boolean;
}

export interface OfflinePlayer extends ServerOperator, AnimalTamer, ConfigurationSerializable {
    banned: boolean;
    player: Player;
    online: boolean;
    whitelisted: boolean;
    firstPlayed: number;
    lastPlayed: number;
    bedSpawnLocation: Location;
}

export interface Server extends PluginMessageRecipient {
    name: string;
    unsafe: UnsafeValues;
    port: number;
    logger: Logger;
    version: string;
    ticksPerAnimalSpawns: number;
    commandAliases: { [index: string]: string[] };
    generateStructures: boolean;
    updateFolderFile: any;
    whitelistedPlayers: OfflinePlayer[];
    connectionThrottle: number;
    ticksPerMonsterSpawns: number;
    servicesManager: ServicesManager;
    serverName: string;
    allowEnd: boolean;
    viewDistance: number;
    bukkitVersion: string;
    maxPlayers: number;
    scheduler: BukkitScheduler;
    allowNether: boolean;
    serverId: string;
    onlinePlayers: Player[];
    worldType: string;
    updateFolder: string;
    worlds: World[];
    ip: string;
    pluginManager: PluginManager;
    spawnRadius: number;
    messenger: Messenger;
    primaryThread: boolean;
    ipbans: string[];
    warningState: WarningState;
    motd: string;
    onlineMode: boolean;
    hardcore: boolean;
    helpMap: HelpMap;
    idleTimeout: number;
    bannedPlayers: OfflinePlayer[];
    itemFactory: ItemFactory;
    serverIcon: CachedServerIcon;
    commandMap: CommandMap;
    consoleSender: ConsoleCommandSender;
    operators: OfflinePlayer[];
    allowFlight: boolean;
    monsterSpawnLimit: number;
    ambientSpawnLimit: number;
    shutdownMessage: string;
    offlinePlayers: OfflinePlayer[];
    scoreboardManager: ScoreboardManager;
    worldContainer: any;
    animalSpawnLimit: number;
    defaultGameMode: GameMode;
    waterAnimalSpawnLimit: number;
}

export interface TravelAgent {
    searchRadius: number;
    creationRadius: number;
    canCreatePortal: boolean;
}

export interface UnsafeValues {
}

export interface World extends PluginMessageRecipient, Metadatable {
    name: string;
    time: number;
    seed: number;
    ticksPerAnimalSpawns: number;
    ticksPerMonsterSpawns: number;
    worldType: WorldType;
    entities: Entity[];
    thundering: boolean;
    players: Player[];
    uid: string;
    fullTime: number;
    loadedChunks: Chunk[];
    spawnLocation: Location;
    autoSave: boolean;
    difficulty: Difficulty;
    maxHeight: number;
    pvp: boolean;
    allowMonsters: boolean;
    generator: ChunkGenerator;
    gameRules: string[];
    populators: BlockPopulator[];
    environment: Environment;
    allowAnimals: boolean;
    worldBorder: WorldBorder;
    seaLevel: number;
    worldFolder: any;
    monsterSpawnLimit: number;
    thunderDuration: number;
    keepSpawnInMemory: boolean;
    ambientSpawnLimit: number;
    animalSpawnLimit: number;
    weatherDuration: number;
    waterAnimalSpawnLimit: number;
    livingEntities: LivingEntity[];
}

export interface ChunkLoadCallback {
}

export interface WorldBorder {
    size: number;
    center: Location;
    damageBuffer: number;
    damageAmount: number;
    warningTime: number;
    warningDistance: number;
}

export interface WorldCreator {
}

export interface Banner extends BlockState {
    baseColor: DyeColor;
    patterns: any[];
}

export interface Beacon extends BlockState, InventoryHolder {
}

export interface Block extends Metadatable {
    empty: boolean;
    location: Location;
    state: BlockState;
    type: Material;
    world: World;
    data: number;
    typeId: number;
    x: number;
    z: number;
    biome: Biome;
    chunk: Chunk;
    humidity: number;
    temperature: number;
    lightLevel: number;
    lightFromSky: number;
    blockPowered: boolean;
    blockPower: number;
    liquid: boolean;
    drops: ItemStack[];
    y: number;
    pistonMoveReaction: PistonMoveReaction;
    lightFromBlocks: number;
    blockIndirectlyPowered: boolean;
}

export interface BlockState extends Metadatable {
    location: Location;
    type: Material;
    world: World;
    data: any;
    block: Block;
    typeId: number;
    x: number;
    z: number;
    chunk: Chunk;
    lightLevel: number;
    rawData: number;
    placed: boolean;
    y: number;
}

export interface BrewingStand extends BlockState, ContainerBlock {
    inventory: BrewerInventory;
    brewingTime: number;
}

export interface Chest extends BlockState, ContainerBlock {
    blockInventory: Inventory;
}

export interface CommandBlock extends BlockState {
    name: string;
    command: string;
}

export interface ContainerBlock extends InventoryHolder {
}

export interface CreatureSpawner extends BlockState {
    creatureType: CreatureType;
    delay: number;
    spawnedType: EntityType;
    creatureTypeName: string;
    creatureTypeId: string;
}

export interface Dispenser extends BlockState, ContainerBlock {
    blockProjectileSource: BlockProjectileSource;
}

export interface DoubleChest extends InventoryHolder {
    location: Location;
    world: World;
    x: number;
    z: number;
    leftSide: InventoryHolder;
    rightSide: InventoryHolder;
    y: number;
}

export interface Dropper extends BlockState, InventoryHolder {
}

export interface Furnace extends BlockState, ContainerBlock {
    inventory: FurnaceInventory;
    burnTime: number;
    cookTime: number;
}

export interface Hopper extends BlockState, InventoryHolder {
}

export interface Jukebox extends BlockState {
    playing: Material;
}

export interface NoteBlock extends BlockState {
    note: Note;
    rawNote: number;
}

export interface Sign extends BlockState {
    lines: string[];
}

export interface Skull extends BlockState {
    owner: string;
    skullType: SkullType;
    rotation: BlockFace;
}

export interface BlockCommandSender extends CommandSender {
    block: Block;
}

export interface Command {
    name: string;
    label: string;
    aliases: string[];
    description: string;
    permission: string;
    permissionMessage: string;
    timings: CustomTimingsHandler;
    registered: boolean;
    usage: string;
}

export interface CommandException extends RuntimeException {
}

export interface CommandExecutor {
}

export interface CommandMap {
}

export interface CommandSender extends Permissible {
    name: string;
    server: Server;
}

export interface ConsoleCommandSender extends CommandSender, Conversable {
}

export interface FormattedCommandAlias extends Command {
}

export interface MultipleCommandAlias extends Command {
    commands: Command[];
}

export interface PluginCommand extends Command, PluginIdentifiableCommand {
    executor: CommandExecutor;
    tabCompleter: TabCompleter;
}

export interface PluginCommandYamlParser {
}

export interface PluginIdentifiableCommand {
    plugin: Plugin;
}

export interface ProxiedCommandSender extends CommandSender {
    callee: CommandSender;
    caller: CommandSender;
}

export interface RemoteConsoleCommandSender extends CommandSender {
}

export interface SimpleCommandMap extends CommandMap {
    commands: Command[];
}

export interface TabCommandExecutor extends CommandExecutor {
}

export interface TabCompleter {
}

export interface TabExecutor extends TabCompleter, CommandExecutor {
}

export interface AchievementCommand extends VanillaCommand {
}

export interface BanCommand extends VanillaCommand {
}

export interface BanIpCommand extends VanillaCommand {
}

export interface BanListCommand extends VanillaCommand {
}

export interface BukkitCommand extends Command {
}

export interface ClearCommand extends VanillaCommand {
}

export interface DefaultGameModeCommand extends VanillaCommand {
}

export interface DeopCommand extends VanillaCommand {
}

export interface DifficultyCommand extends VanillaCommand {
}

export interface EffectCommand extends VanillaCommand {
}

export interface EnchantCommand extends VanillaCommand {
}

export interface ExpCommand extends VanillaCommand {
}

export interface GameModeCommand extends VanillaCommand {
}

export interface GameRuleCommand extends VanillaCommand {
}

export interface GiveCommand extends VanillaCommand {
}

export interface HelpCommand extends VanillaCommand {
}

export interface KickCommand extends VanillaCommand {
}

export interface KillCommand extends VanillaCommand {
}

export interface ListCommand extends VanillaCommand {
}

export interface MeCommand extends VanillaCommand {
}

export interface OpCommand extends VanillaCommand {
}

export interface PardonCommand extends VanillaCommand {
}

export interface PardonIpCommand extends VanillaCommand {
}

export interface PlaySoundCommand extends VanillaCommand {
}

export interface PluginsCommand extends BukkitCommand {
}

export interface ReloadCommand extends BukkitCommand {
}

export interface SaveCommand extends VanillaCommand {
}

export interface SaveOffCommand extends VanillaCommand {
}

export interface SaveOnCommand extends VanillaCommand {
}

export interface SayCommand extends VanillaCommand {
}

export interface ScoreboardCommand extends VanillaCommand {
}

export interface SeedCommand extends VanillaCommand {
}

export interface SetIdleTimeoutCommand extends VanillaCommand {
}

export interface SetWorldSpawnCommand extends VanillaCommand {
}

export interface SpawnpointCommand extends VanillaCommand {
}

export interface SpreadPlayersCommand extends VanillaCommand {
}

export interface StopCommand extends VanillaCommand {
}

export interface TeleportCommand extends VanillaCommand {
}

export interface TellCommand extends VanillaCommand {
}

export interface TestForCommand extends VanillaCommand {
}

export interface TimeCommand extends VanillaCommand {
}

export interface TimingsCommand extends BukkitCommand {
}

export interface PasteThread extends Thread {
}

export interface ToggleDownfallCommand extends VanillaCommand {
}

export interface VanillaCommand extends Command {
}

export interface VersionCommand extends BukkitCommand {
}

export interface WeatherCommand extends VanillaCommand {
}

export interface WhitelistCommand extends VanillaCommand {
}

export interface Configuration extends ConfigurationSection {
    defaults: Configuration;
}

export interface ConfigurationOptions {
}

export interface ConfigurationSection {
    name: string;
    parent: ConfigurationSection;
    root: Configuration;
    defaultSection: ConfigurationSection;
    currentPath: string;
}

export interface InvalidConfigurationException extends Exception {
}

export interface MemoryConfiguration extends MemorySection, Configuration {
}

export interface MemoryConfigurationOptions extends ConfigurationOptions {
}

export interface MemorySection extends ConfigurationSection {
}

export interface FileConfiguration extends MemoryConfiguration {
}

export interface FileConfigurationOptions extends MemoryConfigurationOptions {
}

export interface YamlConfiguration extends FileConfiguration {
}

export interface YamlConfigurationOptions extends FileConfigurationOptions {
}

export interface YamlConstructor extends SafeConstructor {
}

export interface ConstructCustomObject extends ConstructYamlMap {
}

export interface YamlRepresenter extends Representer {
}

export interface RepresentConfigurationSection extends RepresentMap {
}

export interface RepresentConfigurationSerializable extends RepresentMap {
}

export interface ConfigurationSerializable {
}

export interface ConfigurationSerialization {
}

export interface BooleanPrompt extends ValidatingPrompt {
}

export interface Conversable {
    conversing: boolean;
}

export interface Conversation {
    context: ConversationContext;
    modal: boolean;
    localEchoEnabled: boolean;
    prefix: ConversationPrefix;
    cancellers: ConversationCanceller[];
    state: ConversationState;
    forWhom: Conversable;
}

export interface ConversationAbandonedEvent extends EventObject {
    context: ConversationContext;
    canceller: ConversationCanceller;
}

export interface ConversationAbandonedListener extends EventListener {
}

export interface ConversationCanceller extends Cloneable {
}

export interface ConversationContext {
    forWhom: Conversable;
    plugin: Plugin;
    allSessionData: { [index: string]: any };
}

export interface ConversationFactory {
}

export interface NotPlayerMessagePrompt extends MessagePrompt {
}

export interface ConversationPrefix {
}

export interface ExactMatchConversationCanceller extends ConversationCanceller {
}

export interface FixedSetPrompt extends ValidatingPrompt {
}

export interface InactivityConversationCanceller extends ConversationCanceller {
}

export interface ManuallyAbandonedConversationCanceller extends ConversationCanceller {
}

export interface MessagePrompt extends Prompt {
}

export interface NullConversationPrefix extends ConversationPrefix {
}

export interface NumericPrompt extends ValidatingPrompt {
}

export interface PlayerNamePrompt extends ValidatingPrompt {
}

export interface PluginNameConversationPrefix extends ConversationPrefix {
}

export interface Prompt extends Cloneable {
}

export interface RegexPrompt extends ValidatingPrompt {
}

export interface StringPrompt extends Prompt {
}

export interface ValidatingPrompt extends Prompt {
}

export interface Enchantment {
    id: number;
    name: string;
    startLevel: number;
    maxLevel: number;
    itemTarget: EnchantmentTarget;
}

export interface EnchantmentWrapper extends Enchantment {
    enchantment: Enchantment;
}

export interface Ageable extends Creature {
    age: number;
    ageLock: boolean;
    adult: boolean;
}

export interface Ambient extends LivingEntity {
}

export interface AnimalTamer {
    name: string;
    uniqueId: string;
}

export interface Animals extends Ageable {
}

export interface ArmorStand extends LivingEntity {
    marker: boolean;
    itemInHand: ItemStack;
    boots: ItemStack;
    leggings: ItemStack;
    chestplate: ItemStack;
    rightLegPose: EulerAngle;
    small: boolean;
    headPose: EulerAngle;
    visible: boolean;
    helmet: ItemStack;
    leftLegPose: EulerAngle;
    bodyPose: EulerAngle;
    leftArmPose: EulerAngle;
    rightArmPose: EulerAngle;
}

export interface Arrow extends Projectile {
    critical: boolean;
    knockbackStrength: number;
}

export interface Bat extends Ambient {
    awake: boolean;
}

export interface Blaze extends Monster {
}

export interface Boat extends Vehicle {
    unoccupiedDeceleration: number;
    occupiedDeceleration: number;
    maxSpeed: number;
    workOnLand: boolean;
}

export interface CaveSpider extends Spider {
}

export interface Chicken extends Animals {
}

export interface ComplexEntityPart extends Entity {
    parent: ComplexLivingEntity;
}

export interface ComplexLivingEntity extends LivingEntity {
    parts: ComplexEntityPart[];
}

export interface Cow extends Animals {
}

export interface Creature extends LivingEntity {
    target: LivingEntity;
}

export interface Creeper extends Monster {
    powered: boolean;
}

export interface Damageable extends Entity {
    health: number;
    maxHealth: number;
}

export interface Egg extends Projectile {
}

export interface EnderCrystal extends Entity {
}

export interface EnderDragon extends ComplexLivingEntity {
}

export interface EnderDragonPart extends ComplexEntityPart, Damageable {
    parent: EnderDragon;
}

export interface EnderPearl extends Projectile {
}

export interface EnderSignal extends Entity {
}

export interface Enderman extends Monster {
    carriedMaterial: any;
}

export interface Endermite extends Monster {
}

export interface Entity extends Metadatable, CommandSender {
    empty: boolean;
    location: Location;
    type: EntityType;
    valid: boolean;
    world: World;
    lastDamageCause: EntityDamageEvent;
    uniqueId: string;
    customNameVisible: boolean;
    velocity: Vector;
    entityId: number;
    onGround: boolean;
    fireTicks: number;
    dead: boolean;
    customName: string;
    ticksLived: number;
    vehicle: Entity;
    fallDistance: number;
    passenger: Entity;
    maxFireTicks: number;
    insideVehicle: boolean;
}

export interface ExperienceOrb extends Entity {
    experience: number;
}

export interface Explosive extends Entity {
    yield: number;
    incendiary: boolean;
}

export interface FallingBlock extends Entity {
    blockData: number;
    material: Material;
    blockId: number;
    sourceLoc: Location;
    dropItem: boolean;
}

export interface FallingSand extends FallingBlock {
}

export interface Fireball extends Projectile, Explosive {
    direction: Vector;
}

export interface Firework extends Entity {
    fireworkMeta: FireworkMeta;
}

export interface Fish extends FishHook {
}

export interface FishHook extends Projectile {
    biteChance: number;
}

export interface Flying extends LivingEntity {
}

export interface Ghast extends Flying {
}

export interface Giant extends Monster {
}

export interface Golem extends Creature {
}

export interface Guardian extends Monster {
    elder: boolean;
}

export interface Hanging extends Entity {
    attachedFace: BlockFace;
    facing: BlockFace;
}

export interface Horse extends Animals, Vehicle, InventoryHolder, Tameable {
    variant: Variant;
    color: any;
    maxDomestication: number;
    inventory: HorseInventory;
    style: Style;
    carryingChest: boolean;
    domestication: number;
    jumpStrength: number;
}

export interface HumanEntity extends LivingEntity, AnimalTamer, Permissible, InventoryHolder {
    inventory: PlayerInventory;
    itemInHand: ItemStack;
    gameMode: GameMode;
    blocking: boolean;
    openInventory: InventoryView;
    enderChest: Inventory;
    itemOnCursor: ItemStack;
    sleepTicks: number;
    sleeping: boolean;
    expToLevel: number;
}

export interface IronGolem extends Golem {
    playerCreated: boolean;
}

export interface Item extends Entity {
    itemStack: ItemStack;
    pickupDelay: number;
}

export interface ItemFrame extends Hanging {
    item: ItemStack;
    rotation: Rotation;
}

export interface LargeFireball extends Fireball {
}

export interface LeashHitch extends Hanging {
}

export interface LightningStrike extends Weather {
    effect: boolean;
}

export interface LivingEntity extends Entity, Damageable, ProjectileSource {
    activePotionEffects: PotionEffect[];
    maximumNoDamageTicks: number;
    canPickupItems: boolean;
    removeWhenFarAway: boolean;
    noDamageTicks: number;
    eyeHeight: number;
    eyeLocation: Location;
    maximumAir: number;
    leashHolder: Entity;
    killer: Player;
    leashed: boolean;
    remainingAir: number;
    lastDamage: number;
    equipment: EntityEquipment;
}

export interface MagmaCube extends Slime {
}

export interface Minecart extends Vehicle {
    displayBlockOffset: number;
    flyingVelocityMod: Vector;
    derailedVelocityMod: Vector;
    damage: number;
    maxSpeed: number;
    displayBlock: any;
    slowWhenEmpty: boolean;
}

export interface Monster extends Creature {
}

export interface MushroomCow extends Cow {
}

export interface NPC extends Creature {
}

export interface Ocelot extends Animals, Tameable {
    catType: any;
    sitting: boolean;
}

export interface Painting extends Hanging {
    art: Art;
}

export interface Pig extends Animals, Vehicle {
}

export interface PigZombie extends Zombie {
    anger: number;
    angry: boolean;
}

export interface Player extends HumanEntity, Conversable, CommandSender, OfflinePlayer, PluginMessageRecipient {
    address: InetSocketAddress;
    displayName: string;
    level: number;
    playerTimeRelative: boolean;
    playerListName: string;
    spectatorTarget: Entity;
    sleepingIgnored: boolean;
    playerTimeOffset: number;
    totalExperience: number;
    scoreboard: Scoreboard;
    allowFlight: boolean;
    compassTarget: Location;
    sprinting: boolean;
    sneaking: boolean;
    saturation: number;
    healthScaled: boolean;
    flying: boolean;
    healthScale: number;
    foodLevel: number;
    playerWeather: WeatherType;
    flySpeed: number;
    walkSpeed: number;
    exhaustion: number;
    exp: number;
    playerTime: number;
}

export interface Projectile extends Entity {
    shooter: ProjectileSource;
}

export interface Rabbit extends Animals {
    rabbitType: any;
}

export interface Sheep extends Animals {
    sheared: boolean;
    color: DyeColor;
}

export interface Silverfish extends Monster {
}

export interface Skeleton extends Monster {
    skeletonType: SkeletonType;
}

export interface Slime extends LivingEntity {
    size: number;
}

export interface SmallFireball extends Fireball {
}

export interface Snowball extends Projectile {
}

export interface Snowman extends Golem {
}

export interface Spider extends Monster {
}

export interface Squid extends WaterMob {
}

export interface TNTPrimed extends Explosive {
    source: Entity;
    sourceLoc: Location;
    fuseTicks: number;
}

export interface Tameable {
    owner: AnimalTamer;
    tamed: boolean;
}

export interface ThrownExpBottle extends Projectile {
}

export interface ThrownPotion extends Projectile {
    item: ItemStack;
    effects: PotionEffect[];
}

export interface Vehicle extends Entity {
}

export interface Villager extends Ageable, NPC {
    profession: Profession;
}

export interface WaterMob extends LivingEntity {
}

export interface Weather extends Entity {
}

export interface Witch extends Monster {
}

export interface Wither extends Monster {
}

export interface WitherSkull extends Fireball {
    charged: boolean;
}

export interface Wolf extends Animals, Tameable {
    angry: boolean;
    sitting: boolean;
    collarColor: DyeColor;
}

export interface Zombie extends Monster {
    baby: boolean;
    villager: boolean;
}

export interface CommandMinecart extends Minecart, CommandSender {
    command: string;
}

export interface ExplosiveMinecart extends Minecart {
}

export interface HopperMinecart extends Minecart, InventoryHolder {
}

export interface RideableMinecart extends Minecart {
}

export interface SpawnerMinecart extends Minecart {
}

export interface Cancellable {
    cancelled: boolean;
}

export interface Event {
    handlers: HandlerList;
    asynchronous: boolean;
    eventName: string;
}

export interface EventException extends Exception {
}

export interface HandlerList {
    registeredListeners: RegisteredListener[];
}

export interface Listener {
}

export interface BlockBreakEvent extends BlockExpEvent, Cancellable {
    player: Player;
}

export interface BlockBurnEvent extends BlockEvent, Cancellable {
}

export interface BlockCanBuildEvent extends BlockEvent {
    buildable: boolean;
    material: Material;
    materialId: number;
}

export interface BlockDamageEvent extends BlockEvent, Cancellable {
    player: Player;
    instaBreak: boolean;
    itemInHand: ItemStack;
}

export interface BlockDispenseEvent extends BlockEvent, Cancellable {
    item: ItemStack;
    velocity: Vector;
}

export interface BlockEvent extends Event {
    block: Block;
}

export interface BlockExpEvent extends BlockEvent {
    expToDrop: number;
}

export interface BlockExplodeEvent extends BlockEvent, Cancellable {
    yield: number;
}

export interface BlockFadeEvent extends BlockEvent, Cancellable {
    newState: BlockState;
}

export interface BlockFormEvent extends BlockGrowEvent, Cancellable {
}

export interface BlockFromToEvent extends BlockEvent, Cancellable {
    face: BlockFace;
    toBlock: Block;
}

export interface BlockGenerateEvent extends BlockEvent {
}

export interface BlockGrowEvent extends BlockEvent, Cancellable {
    newState: BlockState;
}

export interface BlockIgniteEvent extends BlockEvent, Cancellable {
    cause: IgniteCause;
    ignitingEntity: Entity;
    ignitingBlock: Block;
    player: Player;
}

export interface BlockMultiPlaceEvent extends BlockPlaceEvent {
    replacedBlockStates: BlockState[];
}

export interface BlockPhysicsEvent extends BlockEvent, Cancellable {
    changedTypeId: number;
    changedType: Material;
}

export interface BlockPistonEvent extends BlockEvent, Cancellable {
    direction: BlockFace;
    sticky: boolean;
}

export interface BlockPistonExtendEvent extends BlockPistonEvent {
    length: number;
    blocks: Block[];
}

export interface BlockPistonRetractEvent extends BlockPistonEvent {
    blocks: Block[];
    retractLocation: Location;
}

export interface BlockPlaceEvent extends BlockEvent, Cancellable {
    itemInHand: ItemStack;
    player: Player;
    blockReplacedState: BlockState;
    blockAgainst: Block;
    blockPlaced: Block;
}

export interface BlockRedstoneEvent extends BlockEvent {
    oldCurrent: number;
    newCurrent: number;
}

export interface BlockSpreadEvent extends BlockFormEvent {
    source: Block;
}

export interface EntityBlockFormEvent extends BlockFormEvent {
    entity: Entity;
}

export interface LeavesDecayEvent extends BlockEvent, Cancellable {
}

export interface NotePlayEvent extends BlockEvent, Cancellable {
    instrument: Instrument;
    note: Note;
}

export interface SignChangeEvent extends BlockEvent, Cancellable {
    player: Player;
    lines: string[];
}

export interface EnchantItemEvent extends InventoryEvent, Cancellable {
    item: ItemStack;
    enchanter: Player;
    enchantBlock: Block;
    expLevelCost: number;
    enchantsToAdd: { [index: string]: number };
}

export interface PrepareItemEnchantEvent extends InventoryEvent, Cancellable {
    item: ItemStack;
    enchanter: Player;
    enchantmentBonus: number;
    expLevelCostsOffered: number[];
    enchantBlock: Block;
}

export interface CreatureSpawnEvent extends EntitySpawnEvent {
    entity: LivingEntity;
    spawnReason: SpawnReason;
    creatureType: CreatureType;
}

export interface CreeperPowerEvent extends EntityEvent, Cancellable {
    entity: Creeper;
    cause: PowerCause;
    lightning: LightningStrike;
}

export interface EntityApplyPotionEffectEvent extends EntityEvent, Cancellable {
    effect: PotionEffect;
}

export interface EntityBreakDoorEvent extends EntityChangeBlockEvent {
    entity: LivingEntity;
}

export interface EntityChangeBlockEvent extends EntityEvent, Cancellable {
    block: Block;
    to: Material;
    data: number;
}

export interface EntityCombustByBlockEvent extends EntityCombustEvent {
    combuster: Block;
}

export interface EntityCombustByEntityEvent extends EntityCombustEvent {
    combuster: Entity;
}

export interface EntityCombustEvent extends EntityEvent, Cancellable {
    duration: number;
}

export interface EntityCreatePortalEvent extends EntityEvent, Cancellable {
    entity: LivingEntity;
    blocks: BlockState[];
    portalType: PortalType;
}

export interface EntityDamageByBlockEvent extends EntityDamageEvent {
    damager: Block;
}

export interface EntityDamageByEntityEvent extends EntityDamageEvent {
    damager: Entity;
}

export interface EntityDamageEvent extends EntityEvent, Cancellable {
    cause: DamageCause;
    damage: number;
    finalDamage: number;
}

export interface EntityDeathEvent extends EntityEvent {
    entity: LivingEntity;
    drops: ItemStack[];
    droppedExp: number;
}

export interface EntityEvent extends Event {
    entity: Entity;
    entityType: EntityType;
}

export interface EntityExplodeEvent extends EntityEvent, Cancellable {
    location: Location;
    yield: number;
}

export interface EntityInteractEvent extends EntityEvent, Cancellable {
    block: Block;
}

export interface EntityPortalEnterEvent extends EntityEvent {
    location: Location;
}

export interface EntityPortalEvent extends EntityTeleportEvent {
    portalTravelAgent: TravelAgent;
}

export interface EntityPortalExitEvent extends EntityTeleportEvent {
    before: Vector;
    after: Vector;
}

export interface EntityRegainHealthEvent extends EntityEvent, Cancellable {
    amount: number;
    regainReason: RegainReason;
}

export interface EntityShootBowEvent extends EntityEvent, Cancellable {
    entity: LivingEntity;
    bow: ItemStack;
    projectile: Entity;
    force: number;
}

export interface EntitySpawnEvent extends EntityEvent, Cancellable {
    location: Location;
}

export interface EntityTameEvent extends EntityEvent, Cancellable {
    entity: LivingEntity;
    owner: AnimalTamer;
}

export interface EntityTargetEvent extends EntityEvent, Cancellable {
    target: Entity;
    reason: TargetReason;
}

export interface EntityTargetLivingEntityEvent extends EntityTargetEvent {
    target: LivingEntity;
}

export interface EntityTeleportEvent extends EntityEvent, Cancellable {
    from: Location;
    to: Location;
}

export interface EntityUnleashEvent extends EntityEvent {
    reason: UnleashReason;
}

export interface ExpBottleEvent extends ProjectileHitEvent {
    entity: ThrownExpBottle;
    showEffect: boolean;
    experience: number;
}

export interface ExplosionPrimeEvent extends EntityEvent, Cancellable {
    radius: number;
    fire: boolean;
}

export interface FireworkExplodeEvent extends EntityEvent, Cancellable {
    entity: Firework;
}

export interface FoodLevelChangeEvent extends EntityEvent, Cancellable {
    entity: HumanEntity;
    foodLevel: number;
}

export interface HorseJumpEvent extends EntityEvent, Cancellable {
    entity: Horse;
    power: number;
}

export interface ItemDespawnEvent extends EntityEvent, Cancellable {
    entity: Item;
    location: Location;
}

export interface ItemMergeEvent extends EntityEvent, Cancellable {
    entity: Item;
    target: Item;
}

export interface ItemSpawnEvent extends EntitySpawnEvent {
    entity: Item;
}

export interface MobDropEvent extends EntityEvent {
    entity: LivingEntity;
    drops: ItemStack[];
}

export interface PigZapEvent extends EntityEvent, Cancellable {
    entity: Pig;
    pigZombie: PigZombie;
    lightning: LightningStrike;
}

export interface PlayerDeathEvent extends EntityDeathEvent {
    entity: Player;
    newExp: number;
    deathMessage: string;
    newLevel: number;
    newTotalExp: number;
    keepLevel: boolean;
    keepInventory: boolean;
}

export interface PlayerLeashEntityEvent extends Event, Cancellable {
    leashHolder: Entity;
    entity: Entity;
    player: Player;
}

export interface PotionSplashEvent extends ProjectileHitEvent, Cancellable {
    entity: ThrownPotion;
    affectedEntities: LivingEntity[];
    potion: ThrownPotion;
}

export interface ProjectileHitEvent extends EntityEvent {
    entity: Projectile;
}

export interface ProjectileLaunchEvent extends EntityEvent, Cancellable {
    entity: Projectile;
}

export interface SheepDyeWoolEvent extends EntityEvent, Cancellable {
    entity: Sheep;
    color: DyeColor;
}

export interface SheepRegrowWoolEvent extends EntityEvent, Cancellable {
    entity: Sheep;
}

export interface SlimeSplitEvent extends EntityEvent, Cancellable {
    entity: Slime;
    count: number;
}

export interface SpawnerPreSpawnEvent extends Event, Cancellable {
    spawnerLevel: number;
    mobName: string;
    location: Location;
    spawnerData: { [index: string]: any };
    spawnAmount: number;
}

export interface SpawnerSpawnEvent extends EntitySpawnEvent {
    spawner: CreatureSpawner;
    spawnerLevel: number;
}

export interface TNTDispenseEvent extends EntityEvent, Cancellable {
    block: Block;
    origin: ItemStack;
    vector: Vector;
}

export interface HangingBreakByEntityEvent extends HangingBreakEvent {
    remover: Entity;
}

export interface HangingBreakEvent extends HangingEvent, Cancellable {
    cause: any;
}

export interface HangingEvent extends Event {
    entity: Hanging;
}

export interface HangingPlaceEvent extends HangingEvent, Cancellable {
    player: Player;
    block: Block;
    blockFace: BlockFace;
}

export interface BrewEvent extends BlockEvent, Cancellable {
    contents: BrewerInventory;
}

export interface CraftItemEvent extends InventoryClickEvent {
    recipe: Recipe;
    inventory: CraftingInventory;
}

export interface FurnaceBurnEvent extends BlockEvent, Cancellable {
    fuel: ItemStack;
    burnTime: number;
    burning: boolean;
    furnace: Block;
}

export interface FurnaceExtractEvent extends BlockExpEvent {
    player: Player;
    itemType: Material;
    itemAmount: number;
}

export interface FurnaceSmeltEvent extends BlockEvent, Cancellable {
    source: ItemStack;
    result: ItemStack;
    furnace: Block;
}

export interface InventoryClickEvent extends InventoryInteractEvent {
    click: ClickType;
    action: InventoryAction;
    clickedInventory: Inventory;
    rawSlot: number;
    slot: number;
    shiftClick: boolean;
    rightClick: boolean;
    leftClick: boolean;
    cursor: ItemStack;
    currentItem: ItemStack;
    hotbarButton: number;
    slotType: SlotType;
}

export interface InventoryCloseEvent extends InventoryEvent {
    player: HumanEntity;
}

export interface InventoryCreativeEvent extends InventoryClickEvent {
}

export interface InventoryDragEvent extends InventoryInteractEvent {
    type: DragType;
    oldCursor: ItemStack;
    inventorySlots: number[];
    cursor: ItemStack;
    rawSlots: number[];
    newItems: { [index: string]: ItemStack };
}

export interface InventoryEvent extends Event {
    inventory: Inventory;
    view: InventoryView;
    viewers: HumanEntity[];
}

export interface InventoryInteractEvent extends InventoryEvent, Cancellable {
    result: any;
    whoClicked: HumanEntity;
}

export interface InventoryMoveItemEvent extends Event, Cancellable {
    source: Inventory;
    item: ItemStack;
    initiator: Inventory;
    destination: Inventory;
}

export interface InventoryOpenEvent extends InventoryEvent, Cancellable {
    player: HumanEntity;
}

export interface InventoryPickupItemEvent extends Event, Cancellable {
    inventory: Inventory;
    item: Item;
}

export interface PrepareItemCraftEvent extends InventoryEvent {
    repair: boolean;
    inventory: CraftingInventory;
    recipe: Recipe;
}

export interface PaintingBreakByEntityEvent extends PaintingBreakEvent {
    remover: Entity;
}

export interface PaintingBreakEvent extends PaintingEvent, Cancellable {
    cause: any;
}

export interface PaintingEvent extends Event {
    painting: Painting;
}

export interface PaintingPlaceEvent extends PaintingEvent, Cancellable {
    player: Player;
    block: Block;
    blockFace: BlockFace;
}

export interface AsyncPlayerChatEvent extends PlayerEvent, Cancellable {
    message: string;
    format: string;
    recipients: Player[];
}

export interface AsyncPlayerPreLoginEvent extends Event {
    name: string;
    result: any;
    uniqueId: string;
    address: InetAddress;
    kickMessage: string;
    loginResult: any;
}

export interface PlayerAchievementAwardedEvent extends PlayerEvent, Cancellable {
    achievement: Achievement;
}

export interface PlayerAnimationEvent extends PlayerEvent, Cancellable {
    animationType: PlayerAnimationType;
}

export interface PlayerArmorStandManipulateEvent extends PlayerInteractEntityEvent {
    playerItem: ItemStack;
    armorStandItem: ItemStack;
    slot: EquipmentSlot;
    rightClicked: ArmorStand;
}

export interface PlayerBedEnterEvent extends PlayerEvent, Cancellable {
    bed: Block;
}

export interface PlayerBedLeaveEvent extends PlayerEvent {
    bed: Block;
}

export interface PlayerBucketEmptyEvent extends PlayerBucketEvent {
}

export interface PlayerBucketEvent extends PlayerEvent, Cancellable {
    itemStack: ItemStack;
    blockClicked: Block;
    blockFace: BlockFace;
    bucket: Material;
}

export interface PlayerBucketFillEvent extends PlayerBucketEvent {
}

export interface PlayerChangedWorldEvent extends PlayerEvent {
    from: World;
}

export interface PlayerChannelEvent extends PlayerEvent {
    channel: string;
}

export interface PlayerChatEvent extends PlayerEvent, Cancellable {
    message: string;
    format: string;
    recipients: Player[];
}

export interface PlayerChatTabCompleteEvent extends PlayerEvent {
    lastToken: string;
    tabCompletions: string[];
    chatMessage: string;
}

export interface PlayerCommandPreprocessEvent extends PlayerEvent, Cancellable {
    message: string;
    format: string;
    recipients: Player[];
}

export interface PlayerDropItemEvent extends PlayerEvent, Cancellable {
    itemDrop: Item;
}

export interface PlayerEditBookEvent extends PlayerEvent, Cancellable {
    previousBookMeta: BookMeta;
    slot: number;
    newBookMeta: BookMeta;
    signing: boolean;
}

export interface PlayerEggThrowEvent extends PlayerEvent {
    egg: Egg;
    hatching: boolean;
    hatchType: CreatureType;
    numHatches: number;
    hatchingType: EntityType;
}

export interface PlayerEvent extends Event {
    player: Player;
}

export interface PlayerExpChangeEvent extends PlayerEvent {
    amount: number;
}

export interface PlayerFishEvent extends PlayerEvent, Cancellable {
    state: any;
    hook: Fish;
    caught: Entity;
    expToDrop: number;
}

export interface PlayerGameModeChangeEvent extends PlayerEvent, Cancellable {
    newGameMode: GameMode;
}

export interface PlayerInitialSpawnEvent extends PlayerEvent {
    spawnLocation: Location;
}

export interface PlayerInteractAtEntityEvent extends PlayerInteractEntityEvent {
    clickedPosition: Vector;
}

export interface PlayerInteractEntityEvent extends PlayerEvent, Cancellable {
    rightClicked: Entity;
}

export interface PlayerInteractEvent extends PlayerEvent, Cancellable {
    item: ItemStack;
    action: Action;
    blockFace: BlockFace;
    material: Material;
    clickedBlock: Block;
    blockInHand: boolean;
}

export interface PlayerInventoryEvent extends PlayerEvent {
    inventory: Inventory;
}

export interface PlayerItemBreakEvent extends PlayerEvent {
    brokenItem: ItemStack;
}

export interface PlayerItemConsumeEvent extends PlayerEvent, Cancellable {
    item: ItemStack;
}

export interface PlayerItemDamageEvent extends PlayerEvent, Cancellable {
    item: ItemStack;
    damage: number;
}

export interface PlayerItemHeldEvent extends PlayerEvent, Cancellable {
    previousSlot: number;
    newSlot: number;
}

export interface PlayerJoinEvent extends PlayerEvent {
    joinMessage: string;
}

export interface PlayerKickEvent extends PlayerEvent, Cancellable {
    leaveMessage: string;
    reason: string;
}

export interface PlayerLevelChangeEvent extends PlayerEvent {
    oldLevel: number;
    newLevel: number;
}

export interface PlayerLocaleChangeEvent extends PlayerEvent {
    oldLocale: string;
    newLocale: string;
}

export interface PlayerLoginEvent extends PlayerEvent {
    address: InetAddress;
    hostname: string;
    result: any;
    realAddress: InetAddress;
    kickMessage: string;
}

export interface PlayerMoveEvent extends PlayerEvent, Cancellable {
    from: Location;
    to: Location;
}

export interface PlayerPickupItemEvent extends PlayerEvent, Cancellable {
    item: Item;
    remaining: number;
}

export interface PlayerPortalEvent extends PlayerTeleportEvent {
    portalTravelAgent: TravelAgent;
}

export interface PlayerPreLoginEvent extends Event {
    name: string;
    result: any;
    uniqueId: string;
    address: InetAddress;
    kickMessage: string;
}

export interface PlayerQuitEvent extends PlayerEvent {
    quitMessage: string;
}

export interface PlayerRegisterChannelEvent extends PlayerChannelEvent {
}

export interface PlayerResourcePackStatusEvent extends PlayerEvent {
    status: Status;
}

export interface PlayerRespawnEvent extends PlayerEvent {
    respawnLocation: Location;
    bedSpawn: boolean;
}

export interface PlayerShearEntityEvent extends PlayerEvent, Cancellable {
    entity: Entity;
}

export interface PlayerStatisticIncrementEvent extends PlayerEvent, Cancellable {
    statistic: Statistic;
    newValue: number;
    entityType: EntityType;
    material: Material;
    previousValue: number;
}

export interface PlayerTeleportEvent extends PlayerMoveEvent {
    cause: TeleportCause;
}

export interface PlayerToggleFlightEvent extends PlayerEvent, Cancellable {
    flying: boolean;
}

export interface PlayerToggleSneakEvent extends PlayerEvent, Cancellable {
    sneaking: boolean;
}

export interface PlayerToggleSprintEvent extends PlayerEvent, Cancellable {
    sprinting: boolean;
}

export interface PlayerUnleashEntityEvent extends EntityUnleashEvent, Cancellable {
    player: Player;
}

export interface PlayerUnregisterChannelEvent extends PlayerChannelEvent {
}

export interface PlayerVelocityEvent extends PlayerEvent, Cancellable {
    velocity: Vector;
}

export interface MapInitializeEvent extends ServerEvent {
    map: MapView;
}

export interface PluginDisableEvent extends PluginEvent {
}

export interface PluginEnableEvent extends PluginEvent {
}

export interface PluginEvent extends ServerEvent {
    plugin: Plugin;
}

export interface RemoteServerCommandEvent extends ServerCommandEvent {
}

export interface ServerCommandEvent extends ServerEvent, Cancellable {
    command: string;
    sender: CommandSender;
}

export interface ServerEvent extends Event {
}

export interface ServerListPingEvent extends ServerEvent, Iterable<Player> {
    address: InetAddress;
    motd: string;
    numPlayers: number;
    maxPlayers: number;
}

export interface ServiceEvent extends ServerEvent {
    provider: RegisteredServiceProvider<any>;
}

export interface ServiceRegisterEvent extends ServiceEvent {
}

export interface ServiceUnregisterEvent extends ServiceEvent {
}

export interface VehicleBlockCollisionEvent extends VehicleCollisionEvent {
    block: Block;
}

export interface VehicleCollisionEvent extends VehicleEvent {
}

export interface VehicleCreateEvent extends VehicleEvent {
}

export interface VehicleDamageEvent extends VehicleEvent, Cancellable {
    attacker: Entity;
    damage: number;
}

export interface VehicleDestroyEvent extends VehicleEvent, Cancellable {
    attacker: Entity;
}

export interface VehicleEnterEvent extends VehicleEvent, Cancellable {
    entered: Entity;
}

export interface VehicleEntityCollisionEvent extends VehicleCollisionEvent, Cancellable {
    entity: Entity;
    pickupCancelled: boolean;
    collisionCancelled: boolean;
}

export interface VehicleEvent extends Event {
    vehicle: Vehicle;
}

export interface VehicleExitEvent extends VehicleEvent, Cancellable {
    exited: LivingEntity;
}

export interface VehicleMoveEvent extends VehicleEvent {
    from: Location;
    to: Location;
}

export interface VehicleUpdateEvent extends VehicleEvent {
}

export interface LightningStrikeEvent extends WeatherEvent, Cancellable {
    lightning: LightningStrike;
}

export interface ThunderChangeEvent extends WeatherEvent, Cancellable {
}

export interface WeatherChangeEvent extends WeatherEvent, Cancellable {
}

export interface WeatherEvent extends Event {
    world: World;
}

export interface ChunkEvent extends WorldEvent {
    chunk: Chunk;
}

export interface ChunkLoadEvent extends ChunkEvent {
    newChunk: boolean;
}

export interface ChunkPopulateEvent extends ChunkEvent {
}

export interface ChunkUnloadEvent extends ChunkEvent, Cancellable {
}

export interface PortalCreateEvent extends WorldEvent, Cancellable {
    blocks: Block[];
    reason: CreateReason;
}

export interface SpawnChangeEvent extends WorldEvent {
    previousLocation: Location;
}

export interface StructureGrowEvent extends WorldEvent, Cancellable {
    location: Location;
    species: TreeType;
    player: Player;
    blocks: BlockState[];
    fromBonemeal: boolean;
}

export interface WorldEvent extends Event {
    world: World;
}

export interface WorldInitEvent extends WorldEvent {
}

export interface WorldLoadEvent extends WorldEvent {
}

export interface WorldSaveEvent extends WorldEvent {
}

export interface WorldUnloadEvent extends WorldEvent, Cancellable {
}

export interface BlockPopulator {
}

export interface ChunkGenerator {
}

export interface BiomeGrid {
}

export interface ChunkData {
    maxHeight: number;
}

export interface GenericCommandHelpTopic extends HelpTopic {
}

export interface HelpMap {
    helpTopics: HelpTopic[];
    ignoredPlugins: string[];
}

export interface HelpTopic {
    name: string;
    shortText: string;
}

export interface HelpTopicComparator extends Comparator<HelpTopic> {
}

export interface TopicNameComparator extends Comparator<string> {
}

export interface HelpTopicFactory<TCommand> {
}

export interface IndexHelpTopic extends HelpTopic {
}

export interface AnvilInventory extends Inventory {
}

export interface BeaconInventory extends Inventory {
    item: ItemStack;
}

export interface BrewerInventory extends Inventory {
    holder: BrewingStand;
    ingredient: ItemStack;
}

export interface CraftingInventory extends Inventory {
    result: ItemStack;
    recipe: Recipe;
    matrix: ItemStack[];
}

export interface DoubleChestInventory extends Inventory {
    holder: DoubleChest;
    leftSide: Inventory;
    rightSide: Inventory;
}

export interface EnchantingInventory extends Inventory {
    item: ItemStack;
    secondary: ItemStack;
}

export interface EntityEquipment {
    holder: Entity;
    itemInHand: ItemStack;
    leggingsDropChance: number;
    bootsDropChance: number;
    itemInHandDropChance: number;
    helmetDropChance: number;
    chestplateDropChance: number;
    armorContents: ItemStack[];
    boots: ItemStack;
    leggings: ItemStack;
    chestplate: ItemStack;
    helmet: ItemStack;
}

export interface FurnaceInventory extends Inventory {
    result: ItemStack;
    holder: Furnace;
    fuel: ItemStack;
    smelting: ItemStack;
}

export interface FurnaceRecipe extends Recipe {
    input: ItemStack;
}

export interface HorseInventory extends Inventory {
    armor: ItemStack;
    saddle: ItemStack;
}

export interface Inventory extends Iterable<ItemStack> {
    name: string;
    type: InventoryType;
    size: number;
    contents: ItemStack[];
    maxStackSize: number;
    holder: InventoryHolder;
    title: string;
    viewers: HumanEntity[];
}

export interface InventoryHolder {
    inventory: Inventory;
}

export interface InventoryView {
    type: InventoryType;
    player: HumanEntity;
    bottomInventory: Inventory;
    cursor: ItemStack;
    title: string;
    topInventory: Inventory;
}

export interface ItemFactory {
    defaultLeatherColor: any;
}

export interface ItemStack extends Cloneable, ConfigurationSerializable {
    type: Material;
    amount: number;
    data: any;
    durability: number;
    typeId: number;
    maxStackSize: number;
    enchantments: { [index: string]: number };
    itemMeta: ItemMeta;
}

export interface MerchantInventory extends Inventory {
}

export interface PlayerInventory extends Inventory {
    holder: HumanEntity;
    itemInHand: ItemStack;
    armorContents: ItemStack[];
    heldItemSlot: number;
    boots: ItemStack;
    leggings: ItemStack;
    chestplate: ItemStack;
    helmet: ItemStack;
}

export interface Recipe {
    result: ItemStack;
}

export interface ShapedRecipe extends Recipe {
    ingredientMap: { [index: string]: ItemStack };
    shape: string[];
}

export interface ShapelessRecipe extends Recipe {
    ingredientList: ItemStack[];
}

export interface BannerMeta extends ItemMeta {
    baseColor: DyeColor;
    patterns: any[];
}

export interface BlockStateMeta extends ItemMeta {
    blockState: BlockState;
}

export interface BookMeta extends ItemMeta {
    title: string;
    author: string;
    pages: string[];
    pageCount: number;
}

export interface EnchantmentStorageMeta extends ItemMeta {
    storedEnchants: { [index: string]: number };
}

export interface FireworkEffectMeta extends ItemMeta {
    effect: FireworkEffect;
}

export interface FireworkMeta extends ItemMeta {
    effectsSize: number;
    power: number;
    effects: FireworkEffect[];
}

export interface ItemMeta extends Cloneable, ConfigurationSerializable {
    displayName: string;
    lore: string[];
    itemFlags: ItemFlag[];
    enchants: { [index: string]: number };
}

export interface LeatherArmorMeta extends ItemMeta {
    color: any;
}

export interface MapMeta extends ItemMeta {
    scaling: boolean;
}

export interface PotionMeta extends ItemMeta {
    customEffects: PotionEffect[];
}

export interface Repairable {
    repairCost: number;
}

export interface SkullMeta extends ItemMeta {
    owner: string;
}

export interface MapCanvas {
    mapView: MapView;
    cursors: MapCursorCollection;
}

export interface MapCursor {
    x: number;
    y: number;
    direction: number;
    type: any;
    visible: boolean;
    rawType: number;
}

export interface MapCursorCollection {
}

export interface MapFont {
    height: number;
}

export interface CharacterSprite {
    width: number;
    height: number;
}

export interface MapPalette {
}

export interface MapRenderer {
    contextual: boolean;
}

export interface MapView {
    id: number;
    world: World;
    scale: Scale;
    renderers: MapRenderer[];
    centerX: number;
    centerZ: number;
    virtual: boolean;
}

export interface MinecraftFont extends MapFont {
}

export interface FixedMetadataValue extends LazyMetadataValue {
}

export interface LazyMetadataValue extends MetadataValueAdapter, MetadataValue {
}

export interface MetadataConversionException extends RuntimeException {
}

export interface MetadataEvaluationException extends RuntimeException {
}

export interface MetadataStore<T> {
}

export interface MetadataStoreBase<T> {
}

export interface MetadataValue {
    owningPlugin: Plugin;
}

export interface MetadataValueAdapter extends MetadataValue {
}

export interface Metadatable {
}

export interface Permissible extends ServerOperator {
    effectivePermissions: PermissionAttachmentInfo[];
}

export interface PermissibleBase extends Permissible {
}

export interface RemoveAttachmentRunnable extends Runnable {
}

export interface Permission {
    name: string;
    children: { [index: string]: boolean };
    description: string;
    default: PermissionDefault;
    permissibles: Permissible[];
}

export interface PermissionAttachment {
    permissions: { [index: string]: boolean };
    permissible: Permissible;
    plugin: Plugin;
    removalCallback: PermissionRemovedExecutor;
}

export interface PermissionAttachmentInfo {
    permissible: Permissible;
    permission: string;
    attachment: PermissionAttachment;
    value: boolean;
}

export interface PermissionRemovedExecutor {
}

export interface ServerOperator {
    op: boolean;
}

export interface AuthorNagException extends RuntimeException {
}

export interface EventExecutor {
}

export interface IllegalPluginAccessException extends RuntimeException {
}

export interface InvalidDescriptionException extends Exception {
}

export interface InvalidPluginException extends Exception {
}

export interface Plugin extends TabExecutor {
    name: string;
    logger: Logger;
    enabled: boolean;
    description: PluginDescriptionFile;
    server: Server;
    config: FileConfiguration;
    naggable: boolean;
    database: EbeanServer;
    pluginLoader: PluginLoader;
    dataFolder: any;
}

export interface PluginAwareness {
}

export interface PluginBase extends Plugin {
}

export interface PluginDescriptionFile {
    rawName: string;
    name: string;
    main: string;
    classLoaderOf: string;
    depend: string[];
    softDepend: string[];
    loadBefore: string[];
    version: string;
    commands: { [index: string]: { [index: string]: any } };
    description: string;
    authors: string[];
    website: string;
    prefix: string;
    permissions: Permission[];
    awareness: PluginAwareness[];
    fullName: string;
    databaseEnabled: boolean;
    permissionDefault: PermissionDefault;
    load: PluginLoadOrder;
}

export interface PluginLoader {
    pluginFileFilters: any[];
}

export interface PluginLogger extends Logger {
}

export interface PluginManager {
    permissions: Permission[];
    plugins: Plugin[];
}

export interface RegisteredListener {
    listener: Listener;
    priority: EventPriority;
    plugin: Plugin;
    ignoringCancelled: boolean;
}

export interface RegisteredServiceProvider<T> extends Comparable<RegisteredServiceProvider<any>> {
    service: Class<T>;
    plugin: Plugin;
    provider: T;
    priority: ServicePriority;
}

export interface ServicesManager {
    knownServices: Class<any>[];
}

export interface SimplePluginManager extends PluginManager {
}

export interface SimpleServicesManager extends ServicesManager {
}

export interface TimedRegisteredListener extends RegisteredListener {
    count: number;
    totalTime: number;
    eventClass: Class<Event>;
}

export interface UnknownDependencyException extends RuntimeException {
}

export interface JavaPlugin extends PluginBase {
    initialized: boolean;
    databaseClasses: Class<any>[];
}

export interface JavaPluginLoader extends PluginLoader {
}

export interface PluginClassLoader extends URLClassLoader {
}

export interface ChannelNameTooLongException extends RuntimeException {
}

export interface ChannelNotRegisteredException extends RuntimeException {
}

export interface MessageTooLargeException extends RuntimeException {
}

export interface Messenger {
    outgoingChannels: string[];
    incomingChannels: string[];
}

export interface PluginMessageListener {
}

export interface PluginMessageListenerRegistration {
    plugin: Plugin;
    channel: string;
    listener: PluginMessageListener;
    valid: boolean;
}

export interface PluginMessageRecipient {
    listeningPluginChannels: string[];
}

export interface ReservedChannelException extends RuntimeException {
}

export interface StandardMessenger extends Messenger {
}

export interface Potion {
    splash: boolean;
    level: number;
    type: PotionType;
    tier: Tier;
    nameId: number;
    effects: PotionEffect[];
}

export interface PotionBrewer {
}

export interface PotionEffect extends ConfigurationSerializable {
    amplifier: number;
    duration: number;
    type: PotionEffectType;
    ambient: boolean;
}

export interface PotionEffectType {
    id: number;
    name: string;
    instant: boolean;
    durationModifier: number;
}

export interface PotionEffectTypeWrapper extends PotionEffectType {
    type: PotionEffectType;
}

export interface BlockProjectileSource extends ProjectileSource {
    block: Block;
}

export interface ProjectileSource {
}

export interface BukkitRunnable extends Runnable {
    taskId: number;
}

export interface BukkitScheduler {
    activeWorkers: BukkitWorker[];
    pendingTasks: BukkitTask[];
}

export interface BukkitTask {
    owner: Plugin;
    taskId: number;
    sync: boolean;
}

export interface BukkitWorker {
    owner: Plugin;
    taskId: number;
    thread: Thread;
}

export interface Criterias {
}

export interface Objective {
    name: string;
    displayName: string;
    scoreboard: Scoreboard;
    modifiable: boolean;
    displaySlot: DisplaySlot;
    criteria: string;
}

export interface Score {
    entry: string;
    scoreboard: Scoreboard;
    player: OfflinePlayer;
    objective: Objective;
    score: number;
    scoreSet: boolean;
}

export interface Scoreboard {
    entries: string[];
    players: OfflinePlayer[];
    objectives: Objective[];
    teams: Team[];
}

export interface ScoreboardManager {
    mainScoreboard: Scoreboard;
    newScoreboard: Scoreboard;
}

export interface Team {
    name: string;
    size: number;
    entries: string[];
    displayName: string;
    prefix: string;
    suffix: string;
    scoreboard: Scoreboard;
    players: OfflinePlayer[];
    nameTagVisibility: NameTagVisibility;
}

export interface BlockIterator extends Iterator<Block> {
}

export interface BlockVector extends Vector {
}

export interface CachedServerIcon {
}

export interface ChatPaginator {
}

export interface ChatPage {
    lines: string[];
    pageNumber: number;
    totalPages: number;
}

export interface EulerAngle {
    x: number;
    y: number;
    z: number;
}

export interface FileUtil {
}

export interface Java15Compat {
}

export interface NumberConversions {
}

export interface StringUtil {
}

export interface Vector extends Cloneable, ConfigurationSerializable {
    x: number;
    y: number;
    z: number;
    blockZ: number;
    blockY: number;
    blockX: number;
}

export interface BukkitObjectOutputStream extends ObjectOutputStream {
}

export interface Wrapper<T> extends Serializable {
}

export interface NoiseGenerator {
}

export interface OctaveGenerator {
    octaves: NoiseGenerator[];
    xscale: number;
    zscale: number;
    yscale: number;
}

export interface PerlinNoiseGenerator extends NoiseGenerator {
}

export interface PerlinOctaveGenerator extends OctaveGenerator {
}

export interface SimplexNoiseGenerator extends PerlinNoiseGenerator {
}

export interface SimplexOctaveGenerator extends OctaveGenerator {
    wscale: number;
}

export interface BroadcastPermissions {
}

export interface CommandPermissions {
}

export interface DefaultPermissions {
}

export interface Cloneable {
}

export interface Logger {
    name: string;
    handlers: Handler[];
    useParentHandlers: boolean;
    filter: Filter;
    parent: Logger;
    resourceBundle: ResourceBundle;
    resourceBundleName: string;
    level: Level;
}

export interface CustomTimingsHandler {
}

export interface Throwable extends Serializable {
    cause: Throwable;
    stackTrace: StackTraceElement[];
    localizedMessage: string;
    message: string;
    suppressed: Throwable[];
}

export interface StackTraceElement extends Serializable {
    methodName: string;
    fileName: string;
    lineNumber: number;
    className: string;
    nativeMethod: boolean;
}

export interface RuntimeException extends Exception {
}

export interface ClassLoader {
    parent: ClassLoader;
}

export interface UncaughtExceptionHandler {
}

export interface ThreadGroup extends UncaughtExceptionHandler {
    parent: ThreadGroup;
    name: string;
    maxPriority: number;
    destroyed: boolean;
    daemon: boolean;
}

export interface Thread extends Runnable {
    name: string;
    priority: number;
    daemon: boolean;
    contextClassLoader: ClassLoader;
    uncaughtExceptionHandler: UncaughtExceptionHandler;
    interrupted: boolean;
    threadGroup: ThreadGroup;
    stackTrace: StackTraceElement[];
    id: number;
    state: any;
    alive: boolean;
}

export interface Exception extends Throwable {
}

export interface PropertyUtils {
}

export interface SafeConstructor extends BaseConstructor {
}

export interface ConstructYamlMap extends Construct {
}

export interface TimeZone extends Serializable, Cloneable {
}

export interface Representer extends SafeRepresenter {
}

export interface RepresentMap extends Represent {
}

export interface EventObject extends Serializable {
    source: any;
}

export interface EventListener {
}

export interface InetSocketAddress extends SocketAddress {
}

export interface InetAddress extends Serializable {
}

export interface Runnable {
}

export interface EbeanServer {
    name: string;
    adminAutofetch: AdminAutofetch;
    expressionFactory: ExpressionFactory;
    backgroundExecutor: BackgroundExecutor;
    adminLogging: AdminLogging;
    serverCacheManager: ServerCacheManager;
}

export interface Handler {
    filter: Filter;
    formatter: Formatter;
    errorManager: ErrorManager;
    encoding: string;
    level: Level;
}

export interface Filter {
}

export interface ResourceBundle {
    locale: Locale;
    keys: Enumeration<string>;
    baseBundleName: string;
}

export interface Level extends Serializable {
    name: string;
    resourceBundleName: string;
    localizedName: string;
}

export interface Class<T> extends Serializable, GenericDeclaration, AnnotatedElement {
}

export interface URL extends Serializable {
}

export interface URLClassLoader extends SecureClassLoader, Closeable {
    urls: URL[];
}

export interface ObjectOutputStream extends OutputStream, ObjectOutput, ObjectStreamConstants {
}

export interface Serializable {
}

export interface BaseConstructor {
    propertyUtils: PropertyUtils;
    explicitPropertyUtils: boolean;
    data: any;
}

export interface Construct {
}

export interface SafeRepresenter extends BaseRepresenter {
    timeZone: TimeZone;
}

export interface Represent {
}

export interface SocketAddress extends Serializable {
}

export interface Iterable<T> {
}

export interface Comparator<T> {
}

export interface AdminAutofetch {
    totalTunedQueryCount: number;
    totalProfileSize: number;
    totalTunedQuerySize: number;
    profiling: boolean;
    profilingBase: number;
    profilingMin: number;
    profilingRate: number;
    queryTuning: boolean;
}

export interface ExpressionFactory {
    lang: string;
}

export interface BackgroundExecutor {
}

export interface AdminLogging {
    debugGeneratedSql: boolean;
    debugLazyLoad: boolean;
    logLevel: LogLevel;
}

export interface ServerCacheManager {
}

export interface Formatter {
}

export interface ErrorManager {
}

export interface Locale extends Cloneable, Serializable {
}

export interface Enumeration<E> {
}

export interface GenericDeclaration extends AnnotatedElement {
    typeParameters: TypeVariable<any>[];
}

export interface AnnotatedElement {
    annotations: Annotation[];
    declaredAnnotations: Annotation[];
}

export interface Comparable<T> {
}

export interface SecureClassLoader extends ClassLoader {
}

export interface Closeable extends AutoCloseable {
}

export interface Iterator<E> {
}

export interface OutputStream extends Closeable, Flushable {
}

export interface ObjectOutput extends DataOutput, AutoCloseable {
}

export interface ObjectStreamConstants {
}

export interface BaseRepresenter {
    defaultFlowStyle: FlowStyle;
    propertyUtils: PropertyUtils;
    explicitPropertyUtils: boolean;
}

export interface TypeVariable<D> extends AnnotatedElement {
    name: string;
    annotatedBounds: AnnotatedType[];
    genericDeclaration: D;
    bounds: any[];
    typeName: string;
}

export interface Annotation {
}

export interface AutoCloseable {
}

export interface Flushable {
}

export interface DataOutput {
}

export interface AnnotatedType extends AnnotatedElement {
    type: any;
}

export type Achievement = "OPEN_INVENTORY" | "MINE_WOOD" | "BUILD_WORKBENCH" | "BUILD_PICKAXE" | "BUILD_FURNACE" | "ACQUIRE_IRON" | "BUILD_HOE" | "MAKE_BREAD" | "BAKE_CAKE" | "BUILD_BETTER_PICKAXE" | "COOK_FISH" | "ON_A_RAIL" | "BUILD_SWORD" | "KILL_ENEMY" | "KILL_COW" | "FLY_PIG" | "SNIPE_SKELETON" | "GET_DIAMONDS" | "NETHER_PORTAL" | "GHAST_RETURN" | "GET_BLAZE_ROD" | "BREW_POTION" | "END_PORTAL" | "THE_END" | "ENCHANTMENTS" | "OVERKILL" | "BOOKCASE" | "EXPLORE_ALL_BIOMES" | "SPAWN_WITHER" | "KILL_WITHER" | "FULL_BEACON" | "BREED_COW" | "DIAMONDS_TO_YOU" | "OVERPOWERED";

export type Art = "KEBAB" | "AZTEC" | "ALBAN" | "AZTEC2" | "BOMB" | "PLANT" | "WASTELAND" | "POOL" | "COURBET" | "SEA" | "SUNSET" | "CREEBET" | "WANDERER" | "GRAHAM" | "MATCH" | "BUST" | "STAGE" | "VOID" | "SKULL_AND_ROSES" | "WITHER" | "FIGHTERS" | "POINTER" | "PIGSCENE" | "BURNINGSKULL" | "SKELETON" | "DONKEYKONG";

export type ChatColor = "BLACK" | "DARK_BLUE" | "DARK_GREEN" | "DARK_AQUA" | "DARK_RED" | "DARK_PURPLE" | "GOLD" | "GRAY" | "DARK_GRAY" | "BLUE" | "GREEN" | "AQUA" | "RED" | "LIGHT_PURPLE" | "YELLOW" | "WHITE" | "MAGIC" | "BOLD" | "STRIKETHROUGH" | "UNDERLINE" | "ITALIC" | "RESET";

export type CoalType = "COAL" | "CHARCOAL";

export type CropState = "SEEDED" | "GERMINATED" | "VERY_SMALL" | "SMALL" | "MEDIUM" | "TALL" | "VERY_TALL" | "RIPE";

export type Difficulty = "PEACEFUL" | "EASY" | "NORMAL" | "HARD";

export type DyeColor = "WHITE" | "ORANGE" | "MAGENTA" | "LIGHT_BLUE" | "YELLOW" | "LIME" | "PINK" | "GRAY" | "SILVER" | "CYAN" | "PURPLE" | "BLUE" | "BROWN" | "GREEN" | "RED" | "BLACK";

export type Effect = "CLICK2" | "CLICK1" | "BOW_FIRE" | "DOOR_TOGGLE" | "EXTINGUISH" | "RECORD_PLAY" | "GHAST_SHRIEK" | "GHAST_SHOOT" | "BLAZE_SHOOT" | "ZOMBIE_CHEW_WOODEN_DOOR" | "ZOMBIE_CHEW_IRON_DOOR" | "ZOMBIE_DESTROY_DOOR" | "SMOKE" | "STEP_SOUND" | "POTION_BREAK" | "ENDER_SIGNAL" | "MOBSPAWNER_FLAMES" | "FIREWORKS_SPARK" | "CRIT" | "MAGIC_CRIT" | "POTION_SWIRL" | "POTION_SWIRL_TRANSPARENT" | "SPELL" | "INSTANT_SPELL" | "WITCH_MAGIC" | "NOTE" | "PORTAL" | "FLYING_GLYPH" | "FLAME" | "LAVA_POP" | "FOOTSTEP" | "SPLASH" | "PARTICLE_SMOKE" | "EXPLOSION_HUGE" | "EXPLOSION_LARGE" | "EXPLOSION" | "VOID_FOG" | "SMALL_SMOKE" | "CLOUD" | "COLOURED_DUST" | "SNOWBALL_BREAK" | "WATERDRIP" | "LAVADRIP" | "SNOW_SHOVEL" | "SLIME" | "HEART" | "VILLAGER_THUNDERCLOUD" | "HAPPY_VILLAGER" | "LARGE_SMOKE" | "ITEM_BREAK" | "TILE_BREAK" | "TILE_DUST";

export type EntityEffect = "HURT" | "DEATH" | "WOLF_SMOKE" | "WOLF_HEARTS" | "WOLF_SHAKE" | "SHEEP_EAT" | "IRON_GOLEM_ROSE" | "VILLAGER_HEART" | "VILLAGER_ANGRY" | "VILLAGER_HAPPY" | "WITCH_MAGIC" | "ZOMBIE_TRANSFORM" | "FIREWORK_EXPLODE";

export type GameMode = "CREATIVE" | "SURVIVAL" | "ADVENTURE" | "SPECTATOR";

export type GrassSpecies = "DEAD" | "NORMAL" | "FERN_LIKE";

export type Instrument = "PIANO" | "BASS_DRUM" | "SNARE_DRUM" | "STICKS" | "BASS_GUITAR";

export type Material = "AIR" | "STONE" | "GRASS" | "DIRT" | "COBBLESTONE" | "WOOD" | "SAPLING" | "BEDROCK" | "WATER" | "STATIONARY_WATER" | "LAVA" | "STATIONARY_LAVA" | "SAND" | "GRAVEL" | "GOLD_ORE" | "IRON_ORE" | "COAL_ORE" | "LOG" | "LEAVES" | "SPONGE" | "GLASS" | "LAPIS_ORE" | "LAPIS_BLOCK" | "DISPENSER" | "SANDSTONE" | "NOTE_BLOCK" | "BED_BLOCK" | "POWERED_RAIL" | "DETECTOR_RAIL" | "PISTON_STICKY_BASE" | "WEB" | "LONG_GRASS" | "DEAD_BUSH" | "PISTON_BASE" | "PISTON_EXTENSION" | "WOOL" | "PISTON_MOVING_PIECE" | "YELLOW_FLOWER" | "RED_ROSE" | "BROWN_MUSHROOM" | "RED_MUSHROOM" | "GOLD_BLOCK" | "IRON_BLOCK" | "DOUBLE_STEP" | "STEP" | "BRICK" | "TNT" | "BOOKSHELF" | "MOSSY_COBBLESTONE" | "OBSIDIAN" | "TORCH" | "FIRE" | "MOB_SPAWNER" | "WOOD_STAIRS" | "CHEST" | "REDSTONE_WIRE" | "DIAMOND_ORE" | "DIAMOND_BLOCK" | "WORKBENCH" | "CROPS" | "SOIL" | "FURNACE" | "BURNING_FURNACE" | "SIGN_POST" | "WOODEN_DOOR" | "LADDER" | "RAILS" | "COBBLESTONE_STAIRS" | "WALL_SIGN" | "LEVER" | "STONE_PLATE" | "IRON_DOOR_BLOCK" | "WOOD_PLATE" | "REDSTONE_ORE" | "GLOWING_REDSTONE_ORE" | "REDSTONE_TORCH_OFF" | "REDSTONE_TORCH_ON" | "STONE_BUTTON" | "SNOW" | "ICE" | "SNOW_BLOCK" | "CACTUS" | "CLAY" | "SUGAR_CANE_BLOCK" | "JUKEBOX" | "FENCE" | "PUMPKIN" | "NETHERRACK" | "SOUL_SAND" | "GLOWSTONE" | "PORTAL" | "JACK_O_LANTERN" | "CAKE_BLOCK" | "DIODE_BLOCK_OFF" | "DIODE_BLOCK_ON" | "STAINED_GLASS" | "TRAP_DOOR" | "MONSTER_EGGS" | "SMOOTH_BRICK" | "HUGE_MUSHROOM_1" | "HUGE_MUSHROOM_2" | "IRON_FENCE" | "THIN_GLASS" | "MELON_BLOCK" | "PUMPKIN_STEM" | "MELON_STEM" | "VINE" | "FENCE_GATE" | "BRICK_STAIRS" | "SMOOTH_STAIRS" | "MYCEL" | "WATER_LILY" | "NETHER_BRICK" | "NETHER_FENCE" | "NETHER_BRICK_STAIRS" | "NETHER_WARTS" | "ENCHANTMENT_TABLE" | "BREWING_STAND" | "CAULDRON" | "ENDER_PORTAL" | "ENDER_PORTAL_FRAME" | "ENDER_STONE" | "DRAGON_EGG" | "REDSTONE_LAMP_OFF" | "REDSTONE_LAMP_ON" | "WOOD_DOUBLE_STEP" | "WOOD_STEP" | "COCOA" | "SANDSTONE_STAIRS" | "EMERALD_ORE" | "ENDER_CHEST" | "TRIPWIRE_HOOK" | "TRIPWIRE" | "EMERALD_BLOCK" | "SPRUCE_WOOD_STAIRS" | "BIRCH_WOOD_STAIRS" | "JUNGLE_WOOD_STAIRS" | "COMMAND" | "BEACON" | "COBBLE_WALL" | "FLOWER_POT" | "CARROT" | "POTATO" | "WOOD_BUTTON" | "SKULL" | "ANVIL" | "TRAPPED_CHEST" | "GOLD_PLATE" | "IRON_PLATE" | "REDSTONE_COMPARATOR_OFF" | "REDSTONE_COMPARATOR_ON" | "DAYLIGHT_DETECTOR" | "REDSTONE_BLOCK" | "QUARTZ_ORE" | "HOPPER" | "QUARTZ_BLOCK" | "QUARTZ_STAIRS" | "ACTIVATOR_RAIL" | "DROPPER" | "STAINED_CLAY" | "STAINED_GLASS_PANE" | "LEAVES_2" | "LOG_2" | "ACACIA_STAIRS" | "DARK_OAK_STAIRS" | "SLIME_BLOCK" | "BARRIER" | "IRON_TRAPDOOR" | "PRISMARINE" | "SEA_LANTERN" | "HAY_BLOCK" | "CARPET" | "HARD_CLAY" | "COAL_BLOCK" | "PACKED_ICE" | "DOUBLE_PLANT" | "STANDING_BANNER" | "WALL_BANNER" | "DAYLIGHT_DETECTOR_INVERTED" | "RED_SANDSTONE" | "RED_SANDSTONE_STAIRS" | "DOUBLE_STONE_SLAB2" | "STONE_SLAB2" | "SPRUCE_FENCE_GATE" | "BIRCH_FENCE_GATE" | "JUNGLE_FENCE_GATE" | "DARK_OAK_FENCE_GATE" | "ACACIA_FENCE_GATE" | "SPRUCE_FENCE" | "BIRCH_FENCE" | "JUNGLE_FENCE" | "DARK_OAK_FENCE" | "ACACIA_FENCE" | "SPRUCE_DOOR" | "BIRCH_DOOR" | "JUNGLE_DOOR" | "ACACIA_DOOR" | "DARK_OAK_DOOR" | "IRON_SPADE" | "IRON_PICKAXE" | "IRON_AXE" | "FLINT_AND_STEEL" | "APPLE" | "BOW" | "ARROW" | "COAL" | "DIAMOND" | "IRON_INGOT" | "GOLD_INGOT" | "IRON_SWORD" | "WOOD_SWORD" | "WOOD_SPADE" | "WOOD_PICKAXE" | "WOOD_AXE" | "STONE_SWORD" | "STONE_SPADE" | "STONE_PICKAXE" | "STONE_AXE" | "DIAMOND_SWORD" | "DIAMOND_SPADE" | "DIAMOND_PICKAXE" | "DIAMOND_AXE" | "STICK" | "BOWL" | "MUSHROOM_SOUP" | "GOLD_SWORD" | "GOLD_SPADE" | "GOLD_PICKAXE" | "GOLD_AXE" | "STRING" | "FEATHER" | "SULPHUR" | "WOOD_HOE" | "STONE_HOE" | "IRON_HOE" | "DIAMOND_HOE" | "GOLD_HOE" | "SEEDS" | "WHEAT" | "BREAD" | "LEATHER_HELMET" | "LEATHER_CHESTPLATE" | "LEATHER_LEGGINGS" | "LEATHER_BOOTS" | "CHAINMAIL_HELMET" | "CHAINMAIL_CHESTPLATE" | "CHAINMAIL_LEGGINGS" | "CHAINMAIL_BOOTS" | "IRON_HELMET" | "IRON_CHESTPLATE" | "IRON_LEGGINGS" | "IRON_BOOTS" | "DIAMOND_HELMET" | "DIAMOND_CHESTPLATE" | "DIAMOND_LEGGINGS" | "DIAMOND_BOOTS" | "GOLD_HELMET" | "GOLD_CHESTPLATE" | "GOLD_LEGGINGS" | "GOLD_BOOTS" | "FLINT" | "PORK" | "GRILLED_PORK" | "PAINTING" | "GOLDEN_APPLE" | "SIGN" | "WOOD_DOOR" | "BUCKET" | "WATER_BUCKET" | "LAVA_BUCKET" | "MINECART" | "SADDLE" | "IRON_DOOR" | "REDSTONE" | "SNOW_BALL" | "BOAT" | "LEATHER" | "MILK_BUCKET" | "CLAY_BRICK" | "CLAY_BALL" | "SUGAR_CANE" | "PAPER" | "BOOK" | "SLIME_BALL" | "STORAGE_MINECART" | "POWERED_MINECART" | "EGG" | "COMPASS" | "FISHING_ROD" | "WATCH" | "GLOWSTONE_DUST" | "RAW_FISH" | "COOKED_FISH" | "INK_SACK" | "BONE" | "SUGAR" | "CAKE" | "BED" | "DIODE" | "COOKIE" | "MAP" | "SHEARS" | "MELON" | "PUMPKIN_SEEDS" | "MELON_SEEDS" | "RAW_BEEF" | "COOKED_BEEF" | "RAW_CHICKEN" | "COOKED_CHICKEN" | "ROTTEN_FLESH" | "ENDER_PEARL" | "BLAZE_ROD" | "GHAST_TEAR" | "GOLD_NUGGET" | "NETHER_STALK" | "POTION" | "GLASS_BOTTLE" | "SPIDER_EYE" | "FERMENTED_SPIDER_EYE" | "BLAZE_POWDER" | "MAGMA_CREAM" | "BREWING_STAND_ITEM" | "CAULDRON_ITEM" | "EYE_OF_ENDER" | "SPECKLED_MELON" | "MONSTER_EGG" | "EXP_BOTTLE" | "FIREBALL" | "BOOK_AND_QUILL" | "WRITTEN_BOOK" | "EMERALD" | "ITEM_FRAME" | "FLOWER_POT_ITEM" | "CARROT_ITEM" | "POTATO_ITEM" | "BAKED_POTATO" | "POISONOUS_POTATO" | "EMPTY_MAP" | "GOLDEN_CARROT" | "SKULL_ITEM" | "CARROT_STICK" | "NETHER_STAR" | "PUMPKIN_PIE" | "FIREWORK" | "FIREWORK_CHARGE" | "ENCHANTED_BOOK" | "REDSTONE_COMPARATOR" | "NETHER_BRICK_ITEM" | "QUARTZ" | "EXPLOSIVE_MINECART" | "HOPPER_MINECART" | "PRISMARINE_SHARD" | "PRISMARINE_CRYSTALS" | "RABBIT" | "COOKED_RABBIT" | "RABBIT_STEW" | "RABBIT_FOOT" | "RABBIT_HIDE" | "ARMOR_STAND" | "IRON_BARDING" | "GOLD_BARDING" | "DIAMOND_BARDING" | "LEASH" | "NAME_TAG" | "COMMAND_MINECART" | "MUTTON" | "COOKED_MUTTON" | "BANNER" | "SPRUCE_DOOR_ITEM" | "BIRCH_DOOR_ITEM" | "JUNGLE_DOOR_ITEM" | "ACACIA_DOOR_ITEM" | "DARK_OAK_DOOR_ITEM" | "GOLD_RECORD" | "GREEN_RECORD" | "RECORD_3" | "RECORD_4" | "RECORD_5" | "RECORD_6" | "RECORD_7" | "RECORD_8" | "RECORD_9" | "RECORD_10" | "RECORD_11" | "RECORD_12";

export type NetherWartsState = "SEEDED" | "STAGE_ONE" | "STAGE_TWO" | "RIPE";

export type Tone = "G" | "A" | "B" | "C" | "D" | "E" | "F";

export type PortalType = "NETHER" | "ENDER" | "CUSTOM";

export type Rotation = "NONE" | "CLOCKWISE_45" | "CLOCKWISE" | "CLOCKWISE_135" | "FLIPPED" | "FLIPPED_45" | "COUNTER_CLOCKWISE" | "COUNTER_CLOCKWISE_45";

export type SandstoneType = "CRACKED" | "GLYPHED" | "SMOOTH";

export type SkullType = "SKELETON" | "WITHER" | "ZOMBIE" | "PLAYER" | "CREEPER";

export type Sound = "AMBIENCE_CAVE" | "AMBIENCE_RAIN" | "AMBIENCE_THUNDER" | "ANVIL_BREAK" | "ANVIL_LAND" | "ANVIL_USE" | "ARROW_HIT" | "BURP" | "CHEST_CLOSE" | "CHEST_OPEN" | "CLICK" | "DOOR_CLOSE" | "DOOR_OPEN" | "DRINK" | "EAT" | "EXPLODE" | "FALL_BIG" | "FALL_SMALL" | "FIRE" | "FIRE_IGNITE" | "FIZZ" | "FUSE" | "GLASS" | "HURT_FLESH" | "ITEM_BREAK" | "ITEM_PICKUP" | "LAVA" | "LAVA_POP" | "LEVEL_UP" | "MINECART_BASE" | "MINECART_INSIDE" | "NOTE_BASS" | "NOTE_PIANO" | "NOTE_BASS_DRUM" | "NOTE_STICKS" | "NOTE_BASS_GUITAR" | "NOTE_SNARE_DRUM" | "NOTE_PLING" | "ORB_PICKUP" | "PISTON_EXTEND" | "PISTON_RETRACT" | "PORTAL" | "PORTAL_TRAVEL" | "PORTAL_TRIGGER" | "SHOOT_ARROW" | "SPLASH" | "SPLASH2" | "STEP_GRASS" | "STEP_GRAVEL" | "STEP_LADDER" | "STEP_SAND" | "STEP_SNOW" | "STEP_STONE" | "STEP_WOOD" | "STEP_WOOL" | "SWIM" | "WATER" | "WOOD_CLICK" | "BAT_DEATH" | "BAT_HURT" | "BAT_IDLE" | "BAT_LOOP" | "BAT_TAKEOFF" | "BLAZE_BREATH" | "BLAZE_DEATH" | "BLAZE_HIT" | "CAT_HISS" | "CAT_HIT" | "CAT_MEOW" | "CAT_PURR" | "CAT_PURREOW" | "CHICKEN_IDLE" | "CHICKEN_HURT" | "CHICKEN_EGG_POP" | "CHICKEN_WALK" | "COW_IDLE" | "COW_HURT" | "COW_WALK" | "CREEPER_HISS" | "CREEPER_DEATH" | "ENDERDRAGON_DEATH" | "ENDERDRAGON_GROWL" | "ENDERDRAGON_HIT" | "ENDERDRAGON_WINGS" | "ENDERMAN_DEATH" | "ENDERMAN_HIT" | "ENDERMAN_IDLE" | "ENDERMAN_TELEPORT" | "ENDERMAN_SCREAM" | "ENDERMAN_STARE" | "GHAST_SCREAM" | "GHAST_SCREAM2" | "GHAST_CHARGE" | "GHAST_DEATH" | "GHAST_FIREBALL" | "GHAST_MOAN" | "IRONGOLEM_DEATH" | "IRONGOLEM_HIT" | "IRONGOLEM_THROW" | "IRONGOLEM_WALK" | "MAGMACUBE_WALK" | "MAGMACUBE_WALK2" | "MAGMACUBE_JUMP" | "PIG_IDLE" | "PIG_DEATH" | "PIG_WALK" | "SHEEP_IDLE" | "SHEEP_SHEAR" | "SHEEP_WALK" | "SILVERFISH_HIT" | "SILVERFISH_KILL" | "SILVERFISH_IDLE" | "SILVERFISH_WALK" | "SKELETON_IDLE" | "SKELETON_DEATH" | "SKELETON_HURT" | "SKELETON_WALK" | "SLIME_ATTACK" | "SLIME_WALK" | "SLIME_WALK2" | "SPIDER_IDLE" | "SPIDER_DEATH" | "SPIDER_WALK" | "WITHER_DEATH" | "WITHER_HURT" | "WITHER_IDLE" | "WITHER_SHOOT" | "WITHER_SPAWN" | "WOLF_BARK" | "WOLF_DEATH" | "WOLF_GROWL" | "WOLF_HOWL" | "WOLF_HURT" | "WOLF_PANT" | "WOLF_SHAKE" | "WOLF_WALK" | "WOLF_WHINE" | "ZOMBIE_METAL" | "ZOMBIE_WOOD" | "ZOMBIE_WOODBREAK" | "ZOMBIE_IDLE" | "ZOMBIE_DEATH" | "ZOMBIE_HURT" | "ZOMBIE_INFECT" | "ZOMBIE_UNFECT" | "ZOMBIE_REMEDY" | "ZOMBIE_WALK" | "ZOMBIE_PIG_IDLE" | "ZOMBIE_PIG_ANGRY" | "ZOMBIE_PIG_DEATH" | "ZOMBIE_PIG_HURT" | "DIG_WOOL" | "DIG_GRASS" | "DIG_GRAVEL" | "DIG_SAND" | "DIG_SNOW" | "DIG_STONE" | "DIG_WOOD" | "FIREWORK_BLAST" | "FIREWORK_BLAST2" | "FIREWORK_LARGE_BLAST" | "FIREWORK_LARGE_BLAST2" | "FIREWORK_TWINKLE" | "FIREWORK_TWINKLE2" | "FIREWORK_LAUNCH" | "SUCCESSFUL_HIT" | "HORSE_ANGRY" | "HORSE_ARMOR" | "HORSE_BREATHE" | "HORSE_DEATH" | "HORSE_GALLOP" | "HORSE_HIT" | "HORSE_IDLE" | "HORSE_JUMP" | "HORSE_LAND" | "HORSE_SADDLE" | "HORSE_SOFT" | "HORSE_WOOD" | "DONKEY_ANGRY" | "DONKEY_DEATH" | "DONKEY_HIT" | "DONKEY_IDLE" | "HORSE_SKELETON_DEATH" | "HORSE_SKELETON_HIT" | "HORSE_SKELETON_IDLE" | "HORSE_ZOMBIE_DEATH" | "HORSE_ZOMBIE_HIT" | "HORSE_ZOMBIE_IDLE" | "VILLAGER_DEATH" | "VILLAGER_HAGGLE" | "VILLAGER_HIT" | "VILLAGER_IDLE" | "VILLAGER_NO" | "VILLAGER_YES";

export type Statistic = "DAMAGE_DEALT" | "DAMAGE_TAKEN" | "DEATHS" | "MOB_KILLS" | "PLAYER_KILLS" | "FISH_CAUGHT" | "ANIMALS_BRED" | "TREASURE_FISHED" | "JUNK_FISHED" | "LEAVE_GAME" | "JUMP" | "DROP" | "PLAY_ONE_TICK" | "WALK_ONE_CM" | "SWIM_ONE_CM" | "FALL_ONE_CM" | "CLIMB_ONE_CM" | "FLY_ONE_CM" | "DIVE_ONE_CM" | "MINECART_ONE_CM" | "BOAT_ONE_CM" | "PIG_ONE_CM" | "HORSE_ONE_CM" | "SPRINT_ONE_CM" | "CROUCH_ONE_CM" | "MINE_BLOCK" | "USE_ITEM" | "BREAK_ITEM" | "CRAFT_ITEM" | "KILL_ENTITY" | "ENTITY_KILLED_BY" | "TIME_SINCE_DEATH" | "TALKED_TO_VILLAGER" | "TRADED_WITH_VILLAGER" | "CAKE_SLICES_EATEN" | "CAULDRON_FILLED" | "CAULDRON_USED" | "ARMOR_CLEANED" | "BANNER_CLEANED" | "BREWINGSTAND_INTERACTION" | "BEACON_INTERACTION" | "DROPPER_INSPECTED" | "HOPPER_INSPECTED" | "DISPENSER_INSPECTED" | "NOTEBLOCK_PLAYED" | "NOTEBLOCK_TUNED" | "FLOWER_POTTED" | "TRAPPED_CHEST_TRIGGERED" | "ENDERCHEST_OPENED" | "ITEM_ENCHANTED" | "RECORD_PLAYED" | "FURNACE_INTERACTION" | "CRAFTING_TABLE_INTERACTION" | "CHEST_OPENED";

export type TreeSpecies = "GENERIC" | "REDWOOD" | "BIRCH" | "JUNGLE" | "ACACIA" | "DARK_OAK";

export type TreeType = "TREE" | "BIG_TREE" | "REDWOOD" | "TALL_REDWOOD" | "BIRCH" | "JUNGLE" | "SMALL_JUNGLE" | "COCOA_TREE" | "JUNGLE_BUSH" | "RED_MUSHROOM" | "BROWN_MUSHROOM" | "SWAMP" | "ACACIA" | "DARK_OAK" | "MEGA_REDWOOD" | "TALL_BIRCH";

export type WarningState = "ON" | "OFF" | "DEFAULT";

export type WeatherType = "DOWNFALL" | "CLEAR";

export type Environment = "NORMAL" | "NETHER" | "THE_END";

export type WorldType = "NORMAL" | "FLAT" | "VERSION_1_1" | "LARGE_BIOMES" | "AMPLIFIED" | "CUSTOMIZED";

export type Biome = "SWAMPLAND" | "FOREST" | "TAIGA" | "DESERT" | "PLAINS" | "HELL" | "SKY" | "OCEAN" | "RIVER" | "EXTREME_HILLS" | "FROZEN_OCEAN" | "FROZEN_RIVER" | "ICE_PLAINS" | "ICE_MOUNTAINS" | "MUSHROOM_ISLAND" | "MUSHROOM_SHORE" | "BEACH" | "DESERT_HILLS" | "FOREST_HILLS" | "TAIGA_HILLS" | "SMALL_MOUNTAINS" | "JUNGLE" | "JUNGLE_HILLS" | "JUNGLE_EDGE" | "DEEP_OCEAN" | "STONE_BEACH" | "COLD_BEACH" | "BIRCH_FOREST" | "BIRCH_FOREST_HILLS" | "ROOFED_FOREST" | "COLD_TAIGA" | "COLD_TAIGA_HILLS" | "MEGA_TAIGA" | "MEGA_TAIGA_HILLS" | "EXTREME_HILLS_PLUS" | "SAVANNA" | "SAVANNA_PLATEAU" | "MESA" | "MESA_PLATEAU_FOREST" | "MESA_PLATEAU" | "SUNFLOWER_PLAINS" | "DESERT_MOUNTAINS" | "FLOWER_FOREST" | "TAIGA_MOUNTAINS" | "SWAMPLAND_MOUNTAINS" | "ICE_PLAINS_SPIKES" | "JUNGLE_MOUNTAINS" | "JUNGLE_EDGE_MOUNTAINS" | "COLD_TAIGA_MOUNTAINS" | "SAVANNA_MOUNTAINS" | "SAVANNA_PLATEAU_MOUNTAINS" | "MESA_BRYCE" | "MESA_PLATEAU_FOREST_MOUNTAINS" | "MESA_PLATEAU_MOUNTAINS" | "BIRCH_FOREST_MOUNTAINS" | "BIRCH_FOREST_HILLS_MOUNTAINS" | "ROOFED_FOREST_MOUNTAINS" | "MEGA_SPRUCE_TAIGA" | "EXTREME_HILLS_MOUNTAINS" | "EXTREME_HILLS_PLUS_MOUNTAINS" | "MEGA_SPRUCE_TAIGA_HILLS";

export type BlockFace = "NORTH" | "EAST" | "SOUTH" | "WEST" | "UP" | "DOWN" | "NORTH_EAST" | "NORTH_WEST" | "SOUTH_EAST" | "SOUTH_WEST" | "WEST_NORTH_WEST" | "NORTH_NORTH_WEST" | "NORTH_NORTH_EAST" | "EAST_NORTH_EAST" | "EAST_SOUTH_EAST" | "SOUTH_SOUTH_EAST" | "SOUTH_SOUTH_WEST" | "WEST_SOUTH_WEST" | "SELF";

export type PistonMoveReaction = "MOVE" | "BREAK" | "BLOCK";

export type PatternType = "BASE" | "SQUARE_BOTTOM_LEFT" | "SQUARE_BOTTOM_RIGHT" | "SQUARE_TOP_LEFT" | "SQUARE_TOP_RIGHT" | "STRIPE_BOTTOM" | "STRIPE_TOP" | "STRIPE_LEFT" | "STRIPE_RIGHT" | "STRIPE_CENTER" | "STRIPE_MIDDLE" | "STRIPE_DOWNRIGHT" | "STRIPE_DOWNLEFT" | "STRIPE_SMALL" | "CROSS" | "STRAIGHT_CROSS" | "TRIANGLE_BOTTOM" | "TRIANGLE_TOP" | "TRIANGLES_BOTTOM" | "TRIANGLES_TOP" | "DIAGONAL_LEFT" | "DIAGONAL_RIGHT" | "DIAGONAL_LEFT_MIRROR" | "DIAGONAL_RIGHT_MIRROR" | "CIRCLE_MIDDLE" | "RHOMBUS_MIDDLE" | "HALF_VERTICAL" | "HALF_HORIZONTAL" | "HALF_VERTICAL_MIRROR" | "HALF_HORIZONTAL_MIRROR" | "BORDER" | "CURLY_BORDER" | "CREEPER" | "GRADIENT" | "GRADIENT_UP" | "BRICKS" | "SKULL" | "FLOWER" | "MOJANG";

export type ConversationState = "UNSTARTED" | "STARTED" | "ABANDONED";

export type EnchantmentTarget = "ALL" | "ARMOR" | "ARMOR_FEET" | "ARMOR_LEGS" | "ARMOR_TORSO" | "ARMOR_HEAD" | "WEAPON" | "TOOL" | "BOW" | "FISHING_ROD";

export type CreatureType = "CREEPER" | "SKELETON" | "SPIDER" | "GIANT" | "ZOMBIE" | "SLIME" | "GHAST" | "PIG_ZOMBIE" | "ENDERMAN" | "CAVE_SPIDER" | "SILVERFISH" | "BLAZE" | "MAGMA_CUBE" | "ENDER_DRAGON" | "ENDERMITE" | "GUARDIAN" | "PIG" | "SHEEP" | "COW" | "CHICKEN" | "SQUID" | "WOLF" | "MUSHROOM_COW" | "SNOWMAN" | "RABBIT" | "VILLAGER";

export type EntityType = "DROPPED_ITEM" | "EXPERIENCE_ORB" | "LEASH_HITCH" | "PAINTING" | "ARROW" | "SNOWBALL" | "FIREBALL" | "SMALL_FIREBALL" | "ENDER_PEARL" | "ENDER_SIGNAL" | "THROWN_EXP_BOTTLE" | "ITEM_FRAME" | "WITHER_SKULL" | "PRIMED_TNT" | "FALLING_BLOCK" | "FIREWORK" | "ARMOR_STAND" | "MINECART_COMMAND" | "BOAT" | "MINECART" | "MINECART_CHEST" | "MINECART_FURNACE" | "MINECART_TNT" | "MINECART_HOPPER" | "MINECART_MOB_SPAWNER" | "CREEPER" | "SKELETON" | "SPIDER" | "GIANT" | "ZOMBIE" | "SLIME" | "GHAST" | "PIG_ZOMBIE" | "ENDERMAN" | "CAVE_SPIDER" | "SILVERFISH" | "BLAZE" | "MAGMA_CUBE" | "ENDER_DRAGON" | "WITHER" | "BAT" | "WITCH" | "ENDERMITE" | "GUARDIAN" | "PIG" | "SHEEP" | "COW" | "CHICKEN" | "SQUID" | "WOLF" | "MUSHROOM_COW" | "SNOWMAN" | "OCELOT" | "IRON_GOLEM" | "HORSE" | "RABBIT" | "VILLAGER" | "ENDER_CRYSTAL" | "SPLASH_POTION" | "EGG" | "FISHING_HOOK" | "LIGHTNING" | "WEATHER" | "PLAYER" | "COMPLEX_PART" | "UNKNOWN";

export type Style = "NONE" | "WHITE" | "WHITEFIELD" | "WHITE_DOTS" | "BLACK_DOTS";

export type Variant = "HORSE" | "DONKEY" | "MULE" | "UNDEAD_HORSE" | "SKELETON_HORSE";

export type SkeletonType = "NORMAL" | "WITHER";

export type Profession = "FARMER" | "LIBRARIAN" | "PRIEST" | "BLACKSMITH" | "BUTCHER";

export type EventPriority = "LOWEST" | "LOW" | "NORMAL" | "HIGH" | "HIGHEST" | "MONITOR";

export type Action = "LEFT_CLICK_BLOCK" | "RIGHT_CLICK_BLOCK" | "LEFT_CLICK_AIR" | "RIGHT_CLICK_AIR" | "PHYSICAL";

export type IgniteCause = "LAVA" | "FLINT_AND_STEEL" | "SPREAD" | "LIGHTNING" | "FIREBALL" | "ENDER_CRYSTAL" | "EXPLOSION";

export type SpawnReason = "NATURAL" | "JOCKEY" | "CHUNK_GEN" | "SPAWNER" | "EGG" | "SPAWNER_EGG" | "LIGHTNING" | "BED" | "BUILD_SNOWMAN" | "BUILD_IRONGOLEM" | "BUILD_WITHER" | "VILLAGE_DEFENSE" | "VILLAGE_INVASION" | "BREEDING" | "SLIME_SPLIT" | "REINFORCEMENTS" | "NETHER_PORTAL" | "DISPENSE_EGG" | "INFECTION" | "CURED" | "OCELOT_BABY" | "SILVERFISH_BLOCK" | "MOUNT" | "CUSTOM" | "DEFAULT";

export type PowerCause = "LIGHTNING" | "SET_ON" | "SET_OFF";

export type DamageCause = "CONTACT" | "ENTITY_ATTACK" | "PROJECTILE" | "SUFFOCATION" | "FALL" | "FIRE" | "FIRE_TICK" | "MELTING" | "LAVA" | "DROWNING" | "BLOCK_EXPLOSION" | "ENTITY_EXPLOSION" | "VOID" | "LIGHTNING" | "SUICIDE" | "STARVATION" | "POISON" | "MAGIC" | "WITHER" | "FALLING_BLOCK" | "THORNS" | "CUSTOM";

export type DamageModifier = "BASE" | "HARD_HAT" | "BLOCKING" | "ARMOR" | "RESISTANCE" | "MAGIC" | "ABSORPTION";

export type RegainReason = "REGEN" | "SATIATED" | "EATING" | "ENDER_CRYSTAL" | "MAGIC" | "MAGIC_REGEN" | "WITHER_SPAWN" | "WITHER" | "CUSTOM";

export type TargetReason = "TARGET_DIED" | "CLOSEST_PLAYER" | "TARGET_ATTACKED_ENTITY" | "PIG_ZOMBIE_TARGET" | "FORGOT_TARGET" | "TARGET_ATTACKED_OWNER" | "OWNER_ATTACKED_TARGET" | "RANDOM_TARGET" | "DEFEND_VILLAGE" | "TARGET_ATTACKED_NEARBY_ENTITY" | "REINFORCEMENT_TARGET" | "COLLISION" | "CUSTOM" | "CLOSEST_ENTITY" | "UNKNOWN";

export type UnleashReason = "HOLDER_GONE" | "PLAYER_UNLEASH" | "DISTANCE" | "UNKNOWN";

export type ClickType = "LEFT" | "SHIFT_LEFT" | "RIGHT" | "SHIFT_RIGHT" | "WINDOW_BORDER_LEFT" | "WINDOW_BORDER_RIGHT" | "MIDDLE" | "NUMBER_KEY" | "DOUBLE_CLICK" | "DROP" | "CONTROL_DROP" | "CREATIVE" | "UNKNOWN";

export type DragType = "SINGLE" | "EVEN";

export type InventoryAction = "NOTHING" | "PICKUP_ALL" | "PICKUP_SOME" | "PICKUP_HALF" | "PICKUP_ONE" | "PLACE_ALL" | "PLACE_SOME" | "PLACE_ONE" | "SWAP_WITH_CURSOR" | "DROP_ALL_CURSOR" | "DROP_ONE_CURSOR" | "DROP_ALL_SLOT" | "DROP_ONE_SLOT" | "MOVE_TO_OTHER_INVENTORY" | "HOTBAR_MOVE_AND_READD" | "HOTBAR_SWAP" | "CLONE_STACK" | "COLLECT_TO_CURSOR" | "UNKNOWN";

export type InventoryType = "CHEST" | "DISPENSER" | "DROPPER" | "FURNACE" | "WORKBENCH" | "CRAFTING" | "ENCHANTING" | "BREWING" | "PLAYER" | "CREATIVE" | "MERCHANT" | "ENDER_CHEST" | "ANVIL" | "BEACON" | "HOPPER";

export type SlotType = "RESULT" | "CRAFTING" | "ARMOR" | "CONTAINER" | "QUICKBAR" | "OUTSIDE" | "FUEL";

export type PlayerAnimationType = "ARM_SWING";

export type Status = "SUCCESSFULLY_LOADED" | "DECLINED" | "FAILED_DOWNLOAD" | "ACCEPTED";

export type TeleportCause = "ENDER_PEARL" | "COMMAND" | "PLUGIN" | "NETHER_PORTAL" | "END_PORTAL" | "SPECTATE" | "UNKNOWN";

export type CreateReason = "FIRE" | "OBC_DESTINATION";

export type EquipmentSlot = "HAND" | "FEET" | "LEGS" | "CHEST" | "HEAD";

export type Property = "BREW_TIME" | "COOK_TIME" | "BURN_TIME" | "TICKS_FOR_CURRENT_FUEL" | "ENCHANT_BUTTON1" | "ENCHANT_BUTTON2" | "ENCHANT_BUTTON3";

export type ItemFlag = "HIDE_ENCHANTS" | "HIDE_ATTRIBUTES" | "HIDE_UNBREAKABLE" | "HIDE_DESTROYS" | "HIDE_PLACED_ON" | "HIDE_POTION_EFFECTS";

export type Scale = "CLOSEST" | "CLOSE" | "NORMAL" | "FAR" | "FARTHEST";

export type CacheStrategy = "CACHE_AFTER_FIRST_EVAL" | "NEVER_CACHE" | "CACHE_ETERNALLY";

export type PermissionDefault = "TRUE" | "FALSE" | "OP" | "NOT_OP";

export type Flags = "UTF8";

export type PluginLoadOrder = "STARTUP" | "POSTWORLD";

export type ServicePriority = "Lowest" | "Low" | "Normal" | "High" | "Highest";

export type PluginChannelDirection = "INCOMING" | "OUTGOING";

export type Tier = "ONE" | "TWO";

export type PotionType = "WATER" | "REGEN" | "SPEED" | "FIRE_RESISTANCE" | "POISON" | "INSTANT_HEAL" | "NIGHT_VISION" | "WEAKNESS" | "STRENGTH" | "SLOWNESS" | "JUMP" | "INSTANT_DAMAGE" | "WATER_BREATHING" | "INVISIBILITY";

export type DisplaySlot = "BELOW_NAME" | "PLAYER_LIST" | "SIDEBAR";

export type NameTagVisibility = "ALWAYS" | "NEVER" | "HIDE_FOR_OTHER_TEAMS" | "HIDE_FOR_OWN_TEAM";

export type FlowStyle = "FLOW" | "BLOCK" | "AUTO";

export type LogLevel = "NONE" | "SUMMARY" | "SQL";