@craftjs-typings/worldguard 7.1.0

package/com_sk89q.d.ts

@@ -0,0 +1,1167 @@
+declare module 'com.sk89q.worldguard.bukkit' {
+  import { Location, Material, OfflinePlayer } from 'org.bukkit';
+  import { Block } from 'org.bukkit.block';
+  import { EntityType, Entity, Player } from 'org.bukkit.entity';
+  import { WorldGuardPlatform, StringMatcher, DebugHandler } from 'com.sk89q.worldguard.internal.platform';
+  import { FlagContextBuilder } from 'FlagContext';
+  import { SessionManager } from 'com.sk89q.worldguard.session';
+  import { TextComponent } from 'com.sk89q.worldedit.util.formatting.text';
+  import { RegionContainer, ProtectedRegion } from 'com.sk89q.worldguard.protection.regions';
+  import { GameMode } from 'com.sk89q.worldedit.world.gamemode';
+  import { Path } from 'java.nio.file';
+  import { LocalPlayer } from 'com.sk89q.worldguard';
+  import { ReportList } from 'com.sk89q.worldedit.util.report';
+  import { ProfileService } from 'com.sk89q.worldguard.util.profile.resolver';
+  import { ProfileCache } from 'com.sk89q.worldguard.util.profile.cache';
+  import { World } from 'com.sk89q.worldedit.world';
+  import { ItemStack } from 'org.bukkit.inventory';
+  import { Target } from 'com.sk89q.worldguard.blacklist.target';
+  import { BukkitPlayer as com_sk89q_worldedit_bukkit_BukkitPlayer, WorldEditPlugin } from 'com.sk89q.worldedit.bukkit';
+  import { WeatherType } from 'com.sk89q.worldedit.world.weather';
+  import { Location as com_sk89q_worldedit_util_Location, HandSide } from 'com.sk89q.worldedit.util';
+  import { UUID, Collection, List, Set } from 'java.util';
+  import { BaseItemStack } from 'com.sk89q.worldedit.blocks';
+  import { BlockBag } from 'com.sk89q.worldedit.extent.inventory';
+  import { Vector3 } from 'com.sk89q.worldedit.math';
+  import { BaseEntity } from 'com.sk89q.worldedit.entity';
+  import { SessionKey } from 'com.sk89q.worldedit.session';
+  import { Class, Iterable } from 'java.lang';
+  import { YamlConfigurationManager, YamlWorldConfiguration } from 'com.sk89q.worldguard.config';
+  import { File } from 'java.io';
+  import { JavaPlugin } from 'org.bukkit.plugin.java';
+  import { Actor } from 'com.sk89q.worldedit.extension.platform';
+  import { CommandSender, Command } from 'org.bukkit.command';
+  import { PlayerMoveListener } from 'com.sk89q.worldguard.bukkit.listener';
+  import { WorldLoadEvent, WorldUnloadEvent, ChunkLoadEvent, ChunkUnloadEvent } from 'org.bukkit.event.world';
+  import { TargetMatcherSet } from 'com.sk89q.worldguard.bukkit.internal';
+  import { YAMLProcessor } from 'com.sk89q.util.yaml';
+  import { ChestProtection } from 'com.sk89q.worldguard.chest';
+
+  class ProtectionQuery {
+    testBlockBreak(cause: any, block: Block): boolean;
+    testBlockInteract(cause: any, block: Block): boolean;
+    testBlockPlace(cause: any, location: Location, newMaterial: Material): boolean;
+    testEntityDamage(cause: any, entity: Entity): boolean;
+    testEntityDestroy(cause: any, entity: Entity): boolean;
+    testEntityInteract(cause: any, entity: Entity): boolean;
+    testEntityPlace(cause: any, location: Location, type: EntityType): boolean;
+  }
+
+
+  interface BukkitWorldGuardPlatform extends WorldGuardPlatform {}
+  class BukkitWorldGuardPlatform extends WorldGuardPlatform {
+    constructor();
+    addPlatformReports(report: ReportList): void;
+    broadcastNotification(message: string): void;
+    broadcastNotification(component: TextComponent): void;
+    createProfileService(profileCache: ProfileCache): ProfileService;
+    get configDir(): Path;
+    get debugHandler(): DebugHandler;
+    get defaultGameMode(): GameMode;
+    get globalStateManager(): BukkitConfigurationManager;
+    get matcher(): StringMatcher;
+    get platformName(): string;
+    get platformVersion(): string;
+    get regionContainer(): RegionContainer;
+    get sessionManager(): SessionManager;
+    getSpawnProtection(world: World): ProtectedRegion;
+    load(): void;
+    notifyFlagContextCreate(flagContextBuilder: FlagContextBuilder): void;
+    stackPlayerInventory(localPlayer: LocalPlayer): void;
+    unload(): void;
+  }
+
+
+  class BukkitUtil {
+    static createTarget(block: Block): Target;
+    static createTarget(item: ItemStack): Target;
+    static createTarget(material: Material): Target;
+    static getPotionEffectBits(item: ItemStack): number;
+    static isWaterPotion(item: ItemStack): boolean;
+  }
+
+
+  interface BukkitPlayer extends LocalPlayer, com_sk89q_worldedit_bukkit_BukkitPlayer {}
+  class BukkitPlayer extends LocalPlayer {
+    constructor(plugin: WorldGuardPlugin, player: Player);
+    ban(msg: string): void;
+    get exhaustion(): number;
+    get fireTicks(): number;
+    get foodLevel(): number;
+    get groups(): string[];
+    get health(): number;
+    get maxHealth(): number;
+    get name(): string;
+    get playerTimeOffset(): number;
+    get playerWeather(): WeatherType;
+    get saturation(): number;
+    hasGroup(group: string): boolean;
+    hasPermission(perm: string): boolean;
+    isPlayerTimeRelative(): boolean;
+    kick(msg: string): void;
+    printRaw(msg: string): void;
+    resetFallDistance(): void;
+    resetPlayerTime(): void;
+    resetPlayerWeather(): void;
+    sendTitle(title: string, subtitle: string): void;
+    set exhaustion(exhaustion: number);
+    set fireTicks(fireTicks: number);
+    set foodLevel(foodLevel: number);
+    set health(health: number);
+    set playerWeather(weather: WeatherType);
+    set saturation(saturation: number);
+    setCompassTarget(location: com_sk89q_worldedit_util_Location): void;
+    setPlayerTime(time: number, relative: boolean): void;
+    teleport(location: com_sk89q_worldedit_util_Location, successMessage: string, failMessage: string): void;
+  }
+
+
+  interface BukkitOfflinePlayer extends BukkitPlayer {}
+  class BukkitOfflinePlayer extends BukkitPlayer {
+    ban(msg: string): void;
+    get exhaustion(): number;
+    get foodLevel(): number;
+    get groups(): string[];
+    get health(): number;
+    get inventoryBlockBag(): BlockBag;
+    get location(): com_sk89q_worldedit_util_Location;
+    get maxHealth(): number;
+    get name(): string;
+    get playerTimeOffset(): number;
+    get playerWeather(): WeatherType;
+    get saturation(): number;
+    get sessionKey(): SessionKey;
+    get state(): BaseEntity;
+    get uniqueId(): UUID;
+    get world(): World;
+    getFacet<T>(cls: Class<T>): T;
+    getItemInHand(handSide: HandSide): BaseItemStack;
+    giveItem(itemStack: BaseItemStack): void;
+    hasGroup(group: string): boolean;
+    hasPermission(perm: string): boolean;
+    isPlayerTimeRelative(): boolean;
+    kick(msg: string): void;
+    print(msg: string): void;
+    printDebug(msg: string): void;
+    printError(msg: string): void;
+    printRaw(msg: string): void;
+    resetPlayerTime(): void;
+    resetPlayerWeather(): void;
+    set exhaustion(exhaustion: number);
+    set foodLevel(foodLevel: number);
+    set health(health: number);
+    set playerWeather(weather: WeatherType);
+    set saturation(saturation: number);
+    setCompassTarget(location: com_sk89q_worldedit_util_Location): void;
+    setPlayerTime(time: number, relative: boolean): void;
+    setPosition(pos: Vector3, pitch: number, yaw: number): void;
+  }
+
+
+  interface BukkitConfigurationManager extends YamlConfigurationManager {}
+  class BukkitConfigurationManager extends YamlConfigurationManager {
+    constructor(plugin: WorldGuardPlugin);
+    copyDefaults(): void;
+    get(world: World): BukkitWorldConfiguration;
+    get(worldName: string): BukkitWorldConfiguration;
+    get dataFolder(): File;
+    get worldConfigs(): Collection<BukkitWorldConfiguration>;
+    hasCommandBookGodMode(): boolean;
+    load(): void;
+    postLoad(): void;
+    unload(): void;
+    updateCommandBookGodMode(): void;
+  }
+
+
+  interface WorldGuardPlugin extends JavaPlugin {}
+  class WorldGuardPlugin extends JavaPlugin {
+    constructor();
+    checkPermission(sender: CommandSender, perm: string): void;
+    createDefaultConfiguration(actual: File, defaultName: string): void;
+    createProtectionQuery(): ProtectionQuery;
+    get configManager(): BukkitConfigurationManager;
+    get playerMoveListener(): PlayerMoveListener;
+    get worldEdit(): WorldEditPlugin;
+    getGroups(player: OfflinePlayer): string[];
+    hasPermission(player: Actor, perm: string): boolean;
+    hasPermission(sender: CommandSender, perm: string): boolean;
+    inGroup(player: OfflinePlayer, group: string): boolean;
+    static inst(): WorldGuardPlugin;
+    onCommand(sender: CommandSender, cmd: Command, label: string, args: string[]): boolean;
+    onDisable(): void;
+    onEnable(): void;
+    unwrapActor(sender: Actor): CommandSender;
+    wrapCommandSender(sender: CommandSender): Actor;
+    wrapOfflinePlayer(player: OfflinePlayer): LocalPlayer;
+    wrapPlayer(player: Player): LocalPlayer;
+    wrapPlayer(player: Player, silenced: boolean): LocalPlayer;
+  }
+
+
+  interface BukkitRegionContainer extends RegionContainer {}
+  class BukkitRegionContainer extends RegionContainer {
+    constructor(plugin: WorldGuardPlugin);
+    initialize(): void;
+    onChunkLoad(event: ChunkLoadEvent): void;
+    onChunkUnload(event: ChunkUnloadEvent): void;
+    onWorldLoad(event: WorldLoadEvent): void;
+    onWorldUnload(event: WorldUnloadEvent): void;
+    shutdown(): void;
+  }
+
+
+  interface BukkitDebugHandler extends DebugHandler {}
+  class BukkitDebugHandler extends DebugHandler {
+    testBreak(sender: Actor, target: LocalPlayer, fromTarget: boolean, stackTraceMode: boolean): void;
+    testDamage(sender: Actor, target: LocalPlayer, fromTarget: boolean, stackTraceMode: boolean): void;
+    testInteract(sender: Actor, target: LocalPlayer, fromTarget: boolean, stackTraceMode: boolean): void;
+    testPlace(sender: Actor, target: LocalPlayer, fromTarget: boolean, stackTraceMode: boolean): void;
+  }
+
+
+  interface BukkitStringMatcher extends StringMatcher {}
+  class BukkitStringMatcher extends StringMatcher {
+    getWorldByName(worldName: string): World;
+    matchPlayerNames(filter: string): LocalPlayer[];
+    matchPlayerOrConsole(sender: Actor, filter: string): Actor;
+    matchPlayers(source: Actor, filter: string): Iterable<LocalPlayer>;
+    matchWorld(sender: Actor, filter: string): World;
+    replaceMacros(sender: Actor, message: string): string;
+  }
+
+
+  interface BukkitWorldConfiguration extends YamlWorldConfiguration {}
+  class BukkitWorldConfiguration extends YamlWorldConfiguration {
+    blockPotions: Set;
+    allowAllInteract: TargetMatcherSet;
+    blockUseAtFeet: TargetMatcherSet;
+    usePaperEntityOrigin: boolean;
+    constructor(plugin: WorldGuardPlugin, worldName: string, parentConfig: YAMLProcessor);
+    get chestProtection(): ChestProtection;
+    isAdjacentChestProtected(block: com_sk89q_worldedit_util_Location, player: LocalPlayer): boolean;
+    isChestProtected(block: com_sk89q_worldedit_util_Location, player: LocalPlayer): boolean;
+    isChestProtected(block: com_sk89q_worldedit_util_Location): boolean;
+    isChestProtectedPlacement(block: com_sk89q_worldedit_util_Location, player: LocalPlayer): boolean;
+    loadConfiguration(): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.chest' {
+  import { SignChestProtection } from 'com.sk89q.worldguard.chest';
+  import { Boolean } from 'java.lang';
+  import { Location } from 'com.sk89q.worldedit.util';
+  import { LocalPlayer } from 'com.sk89q.worldguard';
+
+  interface BukkitSignChestProtection extends SignChestProtection {}
+  class BukkitSignChestProtection extends SignChestProtection {
+    isProtectedSign(block: Location, player: LocalPlayer): boolean;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.cause' {
+  import { Player, Entity, EntityType } from 'org.bukkit.entity';
+  import { Block } from 'org.bukkit.block';
+  import { Metadatable } from 'org.bukkit.metadata';
+
+  class Cause {
+    static create(...cause: any[]): Cause;
+    find(...types: EntityType[]): EntityType;
+    get firstBlock(): Block;
+    get firstEntity(): Entity;
+    get firstNonPlayerEntity(): Entity;
+    get firstPlayer(): Player;
+    get rootCause(): any;
+    isIndirect(): boolean;
+    isKnown(): boolean;
+    toString(): string;
+    static trackParentCause(target: Metadatable, parent: any): void;
+    static unknown(): Cause;
+    static untrackParentCause(target: Metadatable): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.session' {
+  import { AbstractSessionManager } from 'com.sk89q.worldguard.session';
+  import { Runnable } from 'java.lang';
+  import { Listener } from 'org.bukkit.event';
+  import { ProcessPlayerEvent } from 'com.sk89q.worldguard.bukkit.event.player';
+  import { LocalPlayer } from 'com.sk89q.worldguard';
+  import { World } from 'com.sk89q.worldedit.world';
+
+  interface BukkitSessionManager extends Runnable, Listener, AbstractSessionManager {}
+  class BukkitSessionManager extends Runnable {
+    hasBypass(player: LocalPlayer, world: World): boolean;
+    onPlayerProcess(event: ProcessPlayerEvent): void;
+    resetAllStates(): void;
+    run(): void;
+    shutdown(): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.internal' {
+  import { Metadatable } from 'org.bukkit.metadata';
+  import { Class } from 'java.lang';
+  import { TargetMatcher, Target } from 'com.sk89q.worldguard.blacklist.target';
+  import { Material } from 'org.bukkit';
+  import { Block, BlockState } from 'org.bukkit.block';
+  import { ItemStack } from 'org.bukkit.inventory';
+
+  class WGMetadata {
+    static getIfPresent<T>(target: Metadatable, key: string, expected: Class<T>): T;
+    static put(target: Metadatable, key: string, value: any): void;
+    static remove(target: Metadatable, key: string): void;
+  }
+
+
+  class TargetMatcherSet {
+    add(matcher: TargetMatcher): boolean;
+    test(target: Target): boolean;
+    test(material: Material): boolean;
+    test(block: Block): boolean;
+    test(state: BlockState): boolean;
+    test(itemStack: ItemStack): boolean;
+    toString(): string;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.util.report' {
+  import { DataReport, Report } from 'com.sk89q.worldedit.util.report';
+  import { List } from 'java.util';
+  import { CancelAttempt } from 'com.sk89q.worldguard.bukkit.event.debug';
+
+  interface SchedulerReport extends DataReport {}
+  class SchedulerReport extends DataReport {
+    constructor();
+  }
+
+
+  interface ServerReport extends DataReport {}
+  class ServerReport extends DataReport {
+    constructor();
+  }
+
+
+  interface CancelReport extends Report {}
+  class CancelReport extends Report {
+    constructor(event: T, cancels: CancelAttempt[], stackTruncateLength: number);
+    get title(): string;
+    isDetectingPlugin(): boolean;
+    setDetectingPlugin(detectingPlugin: boolean): void;
+    toString(): string;
+  }
+
+
+  interface WorldReport extends DataReport {}
+  class WorldReport extends DataReport {
+    constructor();
+  }
+
+
+  interface ServicesReport extends DataReport {}
+  class ServicesReport extends DataReport {
+    constructor();
+  }
+
+
+  interface PluginReport extends DataReport {}
+  class PluginReport extends DataReport {
+    constructor();
+  }
+
+
+  interface DatapackReport extends DataReport {}
+  class DatapackReport extends DataReport {
+    constructor();
+  }
+
+
+  interface PerformanceReport extends DataReport {}
+  class PerformanceReport extends DataReport {
+    constructor();
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.util' {
+  import { Player, EntityType, Entity } from 'org.bukkit.entity';
+  import { Material } from 'org.bukkit';
+  import { Collection, List, Map } from 'java.util';
+  import { PotionEffect } from 'org.bukkit.potion';
+  import { Event, Cancellable } from 'org.bukkit.event';
+  import { PlayerInteractEvent } from 'org.bukkit.event.player';
+  import { BulkEvent } from 'com.sk89q.worldguard.bukkit.event';
+  import { DamageCause } from 'org.bukkit.event.entity.EntityDamageEvent';
+  import { Plugin } from 'org.bukkit.plugin';
+  import { StackTraceElement, Class } from 'java.lang';
+  import { Block } from 'org.bukkit.block';
+
+  class InteropUtils {
+    static isFakePlayer(player: Player): boolean;
+  }
+
+
+  class Materials {
+    static getBucketBlockMaterial(type: Material): Material;
+    static getEntitySpawnEgg(material: Material): EntityType;
+    static getRelatedEntity(material: Material): EntityType;
+    static getRelatedMaterial(type: EntityType): Material;
+    static hasDamageEffect(effects: Collection<PotionEffect>): boolean;
+    static isAmethystGrowth(mat: Material): boolean;
+    static isAnvil(material: Material): boolean;
+    static isArmor(type: Material): boolean;
+    static isBed(material: Material): boolean;
+    static isBlockModifiedOnClick(material: Material, rightClick: boolean): boolean;
+    static isBoat(material: Material): boolean;
+    static isConsideredBuildingIfUsed(type: Material): boolean;
+    static isCoral(material: Material): boolean;
+    static isCrop(type: Material): boolean;
+    static isFire(type: Material): boolean;
+    static isInventoryBlock(material: Material): boolean;
+    static isItemAppliedToBlock(item: Material, block: Material): boolean;
+    static isLava(material: Material): boolean;
+    static isLeaf(material: Material): boolean;
+    static isLiquid(material: Material): boolean;
+    static isMinecart(material: Material): boolean;
+    static isMushroom(material: Material): boolean;
+    static isPistonBlock(material: Material): boolean;
+    static isPortal(material: Material): boolean;
+    static isRailBlock(material: Material): boolean;
+    static isSculkGrowth(mat: Material): boolean;
+    static isShulkerBox(material: Material): boolean;
+    static isSpawnEgg(material: Material): boolean;
+    static isToolApplicable(toolMaterial: Material, targetMaterial: Material): boolean;
+    static isUnwaxedCopper(type: Material): boolean;
+    static isUseFlagApplicable(material: Material): boolean;
+    static isVine(newType: Material): boolean;
+    static isWater(material: Material): boolean;
+    static isWaxedCopper(type: Material): boolean;
+  }
+
+
+  class Events {
+    static fire(event: Event): void;
+    static fireAndTestCancel<T extends Event & Cancellable>(eventToFire: T): boolean;
+    static fireBulkEventToCancel<T extends Event & Cancellable & BulkEvent>(original: Cancellable, eventToFire: T): boolean;
+    static fireItemEventToCancel<T extends Event & Cancellable>(original: PlayerInteractEvent, eventToFire: T): boolean;
+    static fireToCancel<T extends Event & Cancellable>(original: Cancellable, eventToFire: T): boolean;
+    static isExplosionCause(cause: DamageCause): boolean;
+    static isFireCause(cause: DamageCause): boolean;
+    static restoreStatistic(entity: Entity, cause: DamageCause): void;
+  }
+
+
+  class HandlerTracer {
+    constructor(event: Event);
+    detectPlugin(elements: StackTraceElement[]): Plugin;
+  }
+
+
+  class Blocks {
+    static getConnected(block: Block): Block[];
+  }
+
+
+  class ClassSourceValidator {
+    constructor(plugin: Plugin);
+    findMismatches(classes: Class<any>[]): Map<Class<any>, Plugin>;
+    reportMismatches(classes: Class<any>[]): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.event.inventory' {
+  import { DelegateEvent } from 'com.sk89q.worldguard.bukkit.event';
+  import { Event, HandlerList } from 'org.bukkit.event';
+  import { Cause } from 'com.sk89q.worldguard.bukkit.cause';
+  import { World } from 'org.bukkit';
+  import { ItemStack } from 'org.bukkit.inventory';
+
+  interface UseItemEvent extends DelegateEvent {}
+  class UseItemEvent extends DelegateEvent {
+    constructor(originalEvent: Event, cause: Cause, world: World, itemStack: ItemStack);
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+    get itemStack(): ItemStack;
+    get world(): World;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.event.player' {
+  import { Event, HandlerList } from 'org.bukkit.event';
+  import { Player } from 'org.bukkit.entity';
+
+  interface ProcessPlayerEvent extends Event {}
+  class ProcessPlayerEvent extends Event {
+    constructor(player: Player);
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+    get player(): Player;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.event.entity' {
+  import { Event, HandlerList } from 'org.bukkit.event';
+  import { Cause } from 'com.sk89q.worldguard.bukkit.cause';
+  import { Entity, EntityType } from 'org.bukkit.entity';
+  import { Location, World } from 'org.bukkit';
+  import { DelegateEvent } from 'com.sk89q.worldguard.bukkit.event';
+  import { Predicate } from 'com.google.common.base';
+
+  interface UseEntityEvent extends AbstractEntityEvent {}
+  class UseEntityEvent extends AbstractEntityEvent {
+    constructor(originalEvent: Event, cause: Cause, target: Entity);
+    get entity(): Entity;
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+  }
+
+
+  interface SpawnEntityEvent extends AbstractEntityEvent {}
+  class SpawnEntityEvent extends AbstractEntityEvent {
+    constructor(originalEvent: Event, cause: Cause, target: Entity);
+
+    constructor(originalEvent: Event, cause: Cause, location: Location, type: EntityType);
+    get effectiveType(): EntityType;
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+  }
+
+
+  interface AbstractEntityEvent extends DelegateEvent {}
+  class AbstractEntityEvent extends DelegateEvent {
+    filter(predicate: Predicate<Location>, cancelEventOnFalse: boolean): boolean;
+    get entity(): Entity;
+    get target(): Location;
+    get world(): World;
+  }
+
+
+  interface DestroyEntityEvent extends AbstractEntityEvent {}
+  class DestroyEntityEvent extends AbstractEntityEvent {
+    constructor(originalEvent: Event, cause: Cause, target: Entity);
+    get entity(): Entity;
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+  }
+
+
+  interface DamageEntityEvent extends AbstractEntityEvent {}
+  class DamageEntityEvent extends AbstractEntityEvent {
+    constructor(originalEvent: Event, cause: Cause, target: Entity);
+    get entity(): Entity;
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.event' {
+  import { Result } from 'org.bukkit.event.Event';
+  import { Event, Cancellable } from 'org.bukkit.event';
+  import { Cause } from 'com.sk89q.worldguard.bukkit.cause';
+  import { List } from 'java.util';
+  import { StateFlag } from 'com.sk89q.worldguard.protection.flags';
+
+  class Handleable {
+    get result(): Result;
+    set result(result: Result);
+  }
+
+
+  class DelegateEvents {
+    static setAllowed<T extends Handleable>(event: T, allowed: boolean): T;
+    static setSilent<T extends DelegateEvent>(event: T): T;
+    static setSilent<T extends DelegateEvent>(event: T, silent: boolean): T;
+  }
+
+
+  class BulkEvent {
+    get explicitResult(): Result;
+  }
+
+
+  interface DelegateEvent extends Cancellable, Handleable, Event {}
+  class DelegateEvent extends Cancellable {
+    get cause(): Cause;
+    get originalEvent(): Event;
+    get relevantFlags(): StateFlag[];
+    get result(): Result;
+    isCancelled(): boolean;
+    isSilent(): boolean;
+    set result(result: Result);
+    setAllowed(allowed: boolean): DelegateEvent;
+    setCancelled(cancel: boolean): void;
+    setSilent(silent: boolean): DelegateEvent;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.event.block' {
+  import { DelegateEvent, BulkEvent } from 'com.sk89q.worldguard.bukkit.event';
+  import { World, Location, Material } from 'org.bukkit';
+  import { List } from 'java.util';
+  import { Block, BlockState } from 'org.bukkit.block';
+  import { Predicate } from 'java.util.function';
+  import { Event, HandlerList } from 'org.bukkit.event';
+  import { Cause } from 'com.sk89q.worldguard.bukkit.cause';
+
+  interface AbstractBlockEvent extends BulkEvent, DelegateEvent {}
+  class AbstractBlockEvent extends BulkEvent {
+    filter(predicate: Predicate<Location>, cancelEventOnFalse: boolean): boolean;
+    filter(predicate: Predicate<Location>): boolean;
+    get blocks(): Block[];
+    get effectiveMaterial(): Material;
+    get explicitResult(): Result;
+    get result(): Result;
+    get world(): World;
+  }
+
+
+  interface PlaceBlockEvent extends AbstractBlockEvent {}
+  class PlaceBlockEvent extends AbstractBlockEvent {
+    constructor(originalEvent: Event, cause: Cause, world: World, blocks: BlockState[]);
+
+    constructor(originalEvent: Event, cause: Cause, world: World, blocks: Block[], effectiveMaterial: Material);
+
+    constructor(originalEvent: Event, cause: Cause, block: Block);
+
+    constructor(originalEvent: Event, cause: Cause, target: Location, effectiveMaterial: Material);
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+  }
+
+
+  interface UseBlockEvent extends AbstractBlockEvent {}
+  class UseBlockEvent extends AbstractBlockEvent {
+    constructor(originalEvent: Event, cause: Cause, world: World, blocks: Block[], effectiveMaterial: Material);
+
+    constructor(originalEvent: Event, cause: Cause, block: Block);
+
+    constructor(originalEvent: Event, cause: Cause, target: Location, effectiveMaterial: Material);
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+  }
+
+
+  interface BreakBlockEvent extends AbstractBlockEvent {}
+  class BreakBlockEvent extends AbstractBlockEvent {
+    constructor(originalEvent: Event, cause: Cause, world: World, blocks: Block[], effectiveMaterial: Material);
+
+    constructor(originalEvent: Event, cause: Cause, block: Block);
+
+    constructor(originalEvent: Event, cause: Cause, target: Location, effectiveMaterial: Material);
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.event.debug' {
+  import { Cancellable } from 'org.bukkit.event';
+  import { List } from 'java.util';
+  import { StackTraceElement } from 'java.lang';
+  import { BlockPlaceEvent, Action, BlockBreakEvent } from 'org.bukkit.event.block';
+  import { Block, BlockState, BlockFace } from 'org.bukkit.block';
+  import { ItemStack } from 'org.bukkit.inventory';
+  import { Player, Entity } from 'org.bukkit.entity';
+  import { EntityDamageByEntityEvent } from 'org.bukkit.event.entity';
+  import { PlayerInteractEvent } from 'org.bukkit.event.player';
+
+  interface CancelLogging extends Cancellable {}
+  class CancelLogging extends Cancellable {
+    get cancels(): CancelAttempt[];
+  }
+
+
+  class CancelLogger {
+    get cancels(): CancelAttempt[];
+    log(before: boolean, after: boolean, stackTrace: StackTraceElement[]): void;
+  }
+
+
+  interface LoggingBlockPlaceEvent extends CancelLogging, BlockPlaceEvent {}
+  class LoggingBlockPlaceEvent extends CancelLogging {
+    constructor(placedBlock: Block, replacedBlockState: BlockState, placedAgainst: Block, itemInHand: ItemStack, thePlayer: Player, canBuild: boolean);
+    get cancels(): CancelAttempt[];
+    setCancelled(cancel: boolean): void;
+  }
+
+
+  interface LoggingEntityDamageByEntityEvent extends CancelLogging, EntityDamageByEntityEvent {}
+  class LoggingEntityDamageByEntityEvent extends CancelLogging {
+    constructor(damager: Entity, damagee: Entity, cause: DamageCause, damage: number);
+    get cancels(): CancelAttempt[];
+    setCancelled(cancel: boolean): void;
+  }
+
+
+  class CancelAttempt {
+    constructor(before: boolean, after: boolean, stackTrace: StackTraceElement[]);
+    get after(): boolean;
+    get before(): boolean;
+    get stackTrace(): StackTraceElement[];
+  }
+
+
+  interface LoggingPlayerInteractEvent extends CancelLogging, PlayerInteractEvent {}
+  class LoggingPlayerInteractEvent extends CancelLogging {
+    constructor(who: Player, action: Action, item: ItemStack, clickedBlock: Block, clickedFace: BlockFace);
+    get cancels(): CancelAttempt[];
+    setCancelled(cancel: boolean): void;
+    setUseInteractedBlock(useInteractedBlock: Result): void;
+    setUseItemInHand(useItemInHand: Result): void;
+  }
+
+
+  interface LoggingBlockBreakEvent extends CancelLogging, BlockBreakEvent {}
+  class LoggingBlockBreakEvent extends CancelLogging {
+    constructor(block: Block, player: Player);
+    get cancels(): CancelAttempt[];
+    setCancelled(cancel: boolean): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.protection.events.flags' {
+  import { Event, HandlerList } from 'org.bukkit.event';
+  import { FlagContextBuilder } from 'com.sk89q.worldguard.protection.flags.FlagContext';
+
+  interface FlagContextCreateEvent extends Event {}
+  class FlagContextCreateEvent extends Event {
+    constructor(builder: FlagContextBuilder);
+    addObject(key: string, value: any): boolean;
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.protection.events' {
+  import { Event, Cancellable, HandlerList } from 'org.bukkit.event';
+  import { Player } from 'org.bukkit.entity';
+
+  interface DisallowedPVPEvent extends Cancellable, Event {}
+  class DisallowedPVPEvent extends Cancellable {
+    constructor(attacker: Player, defender: Player, event: Event);
+    get attacker(): Player;
+    get cause(): Event;
+    get defender(): Player;
+    static get handlerList(): HandlerList;
+    get handlers(): HandlerList;
+    isCancelled(): boolean;
+    setCancelled(cancelled: boolean): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.listener' {
+  import { WorldGuardPlugin } from 'com.sk89q.worldguard.bukkit';
+  import { ProcessPlayerEvent } from 'com.sk89q.worldguard.bukkit.event.player';
+  import { EntityDamageEvent, EntityCombustEvent, FoodLevelChangeEvent, EntityPotionEffectEvent, EntityChangeBlockEvent, EntityExplodeEvent, EntityInteractEvent, CreatureSpawnEvent, ExpBottleEvent, EntityDeathEvent, EntityUnleashEvent, EntityTameEvent, EntityPickupItemEvent, PotionSplashEvent, LingeringPotionSplashEvent, AreaEffectCloudApplyEvent, ExplosionPrimeEvent, EntityTransformEvent, PigZapEvent, CreeperPowerEvent, EntityRegainHealthEvent, EntityMountEvent } from 'org.bukkit.event.entity';
+  import { SpawnEntityEvent, DestroyEntityEvent, UseEntityEvent, DamageEntityEvent } from 'com.sk89q.worldguard.bukkit.event.entity';
+  import { BlockBreakEvent, BlockMultiPlaceEvent, BlockPlaceEvent, BlockBurnEvent, BlockPistonRetractEvent, BlockPistonExtendEvent, BlockDamageEvent, EntityBlockFormEvent, BlockFertilizeEvent, BlockIgniteEvent, SignChangeEvent, BlockFromToEvent, BlockExpEvent, BlockDispenseEvent, BlockExplodeEvent, CauldronLevelChangeEvent, BlockPhysicsEvent, BlockRedstoneEvent, LeavesDecayEvent, BlockFormEvent, BlockSpreadEvent, BlockGrowEvent, BlockFadeEvent, MoistureChangeEvent, BlockDispenseArmorEvent } from 'org.bukkit.event.block';
+  import { StructureGrowEvent, PortalCreateEvent, ChunkLoadEvent, WorldLoadEvent } from 'org.bukkit.event.world';
+  import { PlayerInteractEvent, PlayerBedEnterEvent, PlayerBucketEmptyEvent, PlayerBucketFillEvent, PlayerFishEvent, PlayerInteractEntityEvent, PlayerShearEntityEvent, PlayerPickupItemEvent, PlayerDropItemEvent, PlayerItemConsumeEvent, PlayerInteractAtEntityEvent, PlayerTakeLecternBookEvent, PlayerItemHeldEvent, PlayerGameModeChangeEvent, PlayerJoinEvent, AsyncPlayerChatEvent, PlayerLoginEvent, PlayerRespawnEvent, PlayerTeleportEvent, PlayerCommandPreprocessEvent, PlayerMoveEvent, PlayerQuitEvent } from 'org.bukkit.event.player';
+  import { HangingPlaceEvent, HangingBreakEvent } from 'org.bukkit.event.hanging';
+  import { VehicleDestroyEvent, VehicleDamageEvent, VehicleEnterEvent, VehicleExitEvent, VehicleMoveEvent } from 'org.bukkit.event.vehicle';
+  import { InventoryOpenEvent, InventoryMoveItemEvent, InventoryClickEvent, InventoryDragEvent, InventoryCreativeEvent } from 'org.bukkit.event.inventory';
+  import { WeatherChangeEvent, ThunderChangeEvent, LightningStrikeEvent } from 'org.bukkit.event.weather';
+  import { PlaceBlockEvent, BreakBlockEvent, UseBlockEvent } from 'com.sk89q.worldguard.bukkit.event.block';
+  import { UseItemEvent } from 'com.sk89q.worldguard.bukkit.event.inventory';
+  import { Listener } from 'org.bukkit.event';
+  import { PluginEnableEvent, PluginDisableEvent } from 'org.bukkit.event.server';
+  import { PlayerWhoisEvent } from 'InfoComponent';
+  import { Logger } from 'java.util.logging';
+  import { World } from 'org.bukkit';
+
+  interface PlayerModesListener extends AbstractListener {}
+  class PlayerModesListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onProcessPlayer(event: ProcessPlayerEvent): void;
+  }
+
+
+  interface InvincibilityListener extends AbstractListener {}
+  class InvincibilityListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onEntityCombust(event: EntityCombustEvent): void;
+    onEntityDamage(event: EntityDamageEvent): void;
+    onFoodLevelChange(event: FoodLevelChangeEvent): void;
+  }
+
+
+  interface WorldRulesListener extends AbstractListener {}
+  class WorldRulesListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onPotionEffect(event: EntityPotionEffectEvent): void;
+    onSpawnEntity(event: SpawnEntityEvent): void;
+  }
+
+
+  interface EventAbstractionListener extends AbstractListener {}
+  class EventAbstractionListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onBedEnter(event: PlayerBedEnterEvent): void;
+    onBlockBreak(event: BlockBreakEvent): void;
+    onBlockBurn(event: BlockBurnEvent): void;
+    onBlockDamage(event: BlockDamageEvent): void;
+    onBlockDispense(event: BlockDispenseEvent): void;
+    onBlockExp(event: BlockExpEvent): void;
+    onBlockExplode(event: BlockExplodeEvent): void;
+    onBlockFertilize(event: BlockFertilizeEvent): void;
+    onBlockFromTo(event: BlockFromToEvent): void;
+    onBlockIgnite(event: BlockIgniteEvent): void;
+    onBlockMultiPlace(event: BlockMultiPlaceEvent): void;
+    onBlockPistonExtend(event: BlockPistonExtendEvent): void;
+    onBlockPistonRetract(event: BlockPistonRetractEvent): void;
+    onBlockPlace(event: BlockPlaceEvent): void;
+    onCauldronLevelChange(event: CauldronLevelChangeEvent): void;
+    onCreatureSpawn(event: CreatureSpawnEvent): void;
+    onEntityBlockForm(event: EntityBlockFormEvent): void;
+    onEntityChangeBlock(event: EntityChangeBlockEvent): void;
+    onEntityCombust(event: EntityCombustEvent): void;
+    onEntityDamage(event: EntityDamageEvent): void;
+    onEntityDeath(event: EntityDeathEvent): void;
+    onEntityExplode(event: EntityExplodeEvent): void;
+    onEntityInteract(event: EntityInteractEvent): void;
+    onEntityPickupItem(event: EntityPickupItemEvent): void;
+    onEntityTame(event: EntityTameEvent): void;
+    onEntityUnleash(event: EntityUnleashEvent): void;
+    onExpBottle(event: ExpBottleEvent): void;
+    onHangingBreak(event: HangingBreakEvent): void;
+    onHangingPlace(event: HangingPlaceEvent): void;
+    onInventoryMoveItem(event: InventoryMoveItemEvent): void;
+    onInventoryOpen(event: InventoryOpenEvent): void;
+    onLingeringApply(event: AreaEffectCloudApplyEvent): void;
+    onLingeringSplash(event: LingeringPotionSplashEvent): void;
+    onPlayerBucketEmpty(event: PlayerBucketEmptyEvent): void;
+    onPlayerBucketFill(event: PlayerBucketFillEvent): void;
+    onPlayerDropItem(event: PlayerDropItemEvent): void;
+    onPlayerFish(event: PlayerFishEvent): void;
+    onPlayerInteract(event: PlayerInteractEvent): void;
+    onPlayerInteractAtEntity(event: PlayerInteractAtEntityEvent): void;
+    onPlayerInteractEntity(event: PlayerInteractEntityEvent): void;
+    onPlayerItemConsume(event: PlayerItemConsumeEvent): void;
+    onPlayerPickupItem(event: PlayerPickupItemEvent): void;
+    onPlayerShearEntity(event: PlayerShearEntityEvent): void;
+    onPotionSplash(event: PotionSplashEvent): void;
+    onSignChange(event: SignChangeEvent): void;
+    onStructureGrowEvent(event: StructureGrowEvent): void;
+    onTakeLecternBook(event: PlayerTakeLecternBookEvent): void;
+    onVehicleDamage(event: VehicleDamageEvent): void;
+    onVehicleDestroy(event: VehicleDestroyEvent): void;
+    registerEvents(): void;
+  }
+
+
+  interface WorldGuardHangingListener extends AbstractListener {}
+  class WorldGuardHangingListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onHangingBreak(event: HangingBreakEvent): void;
+  }
+
+
+  interface WorldGuardWeatherListener extends AbstractListener {}
+  class WorldGuardWeatherListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onLightningStrike(event: LightningStrikeEvent): void;
+    onThunderChange(event: ThunderChangeEvent): void;
+    onWeatherChange(event: WeatherChangeEvent): void;
+  }
+
+
+  interface BuildPermissionListener extends AbstractListener {}
+  class BuildPermissionListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onBreakBlock(event: BreakBlockEvent): void;
+    onDamageEntity(event: DamageEntityEvent): void;
+    onDestroyEntity(event: DestroyEntityEvent): void;
+    onPlaceBlock(event: PlaceBlockEvent): void;
+    onSpawnEntity(event: SpawnEntityEvent): void;
+    onUseBlock(event: UseBlockEvent): void;
+    onUseEntity(event: UseEntityEvent): void;
+    onUseItem(event: UseItemEvent): void;
+  }
+
+
+  interface WorldGuardBlockListener extends AbstractListener {}
+  class WorldGuardBlockListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onBlockBreak(event: BlockBreakEvent): void;
+    onBlockBurn(event: BlockBurnEvent): void;
+    onBlockExplode(event: BlockExplodeEvent): void;
+    onBlockFade(event: BlockFadeEvent): void;
+    onBlockForm(event: BlockFormEvent): void;
+    onBlockFromTo(event: BlockFromToEvent): void;
+    onBlockGrow(event: BlockGrowEvent): void;
+    onBlockIgnite(event: BlockIgniteEvent): void;
+    onBlockPhysics(event: BlockPhysicsEvent): void;
+    onBlockPlace(event: BlockPlaceEvent): void;
+    onBlockRedstoneChange(event: BlockRedstoneEvent): void;
+    onBlockSpread(event: BlockSpreadEvent): void;
+    onLeavesDecay(event: LeavesDecayEvent): void;
+    onMoistureChange(event: MoistureChangeEvent): void;
+  }
+
+
+  interface ChestProtectionListener extends AbstractListener {}
+  class ChestProtectionListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onBreakBlock(event: BreakBlockEvent): void;
+    onPlaceBlock(event: PlaceBlockEvent): void;
+    onSignChange(event: SignChangeEvent): void;
+    onUseBlock(event: UseBlockEvent): void;
+  }
+
+
+  interface BlacklistListener extends AbstractListener {}
+  class BlacklistListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onBlockDispense(event: BlockDispenseEvent): void;
+    onBlockDispenseArmor(event: BlockDispenseArmorEvent): void;
+    onBreakBlock(event: BreakBlockEvent): void;
+    onDestroyEntity(event: DestroyEntityEvent): void;
+    onInventoryClick(event: InventoryClickEvent): void;
+    onInventoryCreative(event: InventoryCreativeEvent): void;
+    onInventoryDrag(event: InventoryDragEvent): void;
+    onPlaceBlock(event: PlaceBlockEvent): void;
+    onPlayerDropItem(event: PlayerDropItemEvent): void;
+    onPlayerItemHeld(event: PlayerItemHeldEvent): void;
+    onSpawnEntity(event: SpawnEntityEvent): void;
+    onUseBlock(event: UseBlockEvent): void;
+    onUseItem(event: UseItemEvent): void;
+  }
+
+
+  interface WorldGuardEntityListener extends AbstractListener {}
+  class WorldGuardEntityListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onCreatePortal(event: PortalCreateEvent): void;
+    onCreatureSpawn(event: CreatureSpawnEvent): void;
+    onCreeperPower(event: CreeperPowerEvent): void;
+    onEntityChangeBlock(event: EntityChangeBlockEvent): void;
+    onEntityDamage(event: EntityDamageEvent): void;
+    onEntityDeath(event: EntityDeathEvent): void;
+    onEntityExplode(event: EntityExplodeEvent): void;
+    onEntityInteract(event: EntityInteractEvent): void;
+    onEntityRegainHealth(event: EntityRegainHealthEvent): void;
+    onEntityTransform(event: EntityTransformEvent): void;
+    onExplosionPrime(event: ExplosionPrimeEvent): void;
+    onFoodChange(event: FoodLevelChangeEvent): void;
+    onPigZap(event: PigZapEvent): void;
+    onVehicleEnter(event: VehicleEnterEvent): void;
+  }
+
+
+  interface RegionProtectionListener extends AbstractListener {}
+  class RegionProtectionListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onBreakBlock(event: BreakBlockEvent): void;
+    onDamageEntity(event: DamageEntityEvent): void;
+    onDestroyEntity(event: DestroyEntityEvent): void;
+    onPlaceBlock(event: PlaceBlockEvent): void;
+    onSpawnEntity(event: SpawnEntityEvent): void;
+    onUseBlock(event: UseBlockEvent): void;
+    onUseEntity(event: UseEntityEvent): void;
+    onVehicleExit(event: VehicleExitEvent): void;
+  }
+
+
+  interface AbstractListener extends Listener {}
+  class AbstractListener extends Listener {
+    constructor(plugin: WorldGuardPlugin);
+    registerEvents(): void;
+  }
+
+
+  interface WorldGuardServerListener extends AbstractListener {}
+  class WorldGuardServerListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onPluginDisable(event: PluginDisableEvent): void;
+    onPluginEnable(event: PluginEnableEvent): void;
+  }
+
+
+  interface WorldGuardCommandBookListener extends Listener {}
+  class WorldGuardCommandBookListener extends Listener {
+    constructor(plugin: WorldGuardPlugin);
+    onPlayerWhois(event: PlayerWhoisEvent): void;
+  }
+
+
+  interface DebuggingListener extends AbstractListener {}
+  class DebuggingListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin, logger: Logger);
+    onBreakBlock(event: BreakBlockEvent): void;
+    onDamageEntity(event: DamageEntityEvent): void;
+    onDestroyEntity(event: DestroyEntityEvent): void;
+    onPlaceBlock(event: PlaceBlockEvent): void;
+    onSpawnEntity(event: SpawnEntityEvent): void;
+    onUseBlock(event: UseBlockEvent): void;
+    onUseEntity(event: UseEntityEvent): void;
+    onUseItem(event: UseItemEvent): void;
+  }
+
+
+  interface RegionFlagsListener extends AbstractListener {}
+  class RegionFlagsListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onBreakBlock(event: BreakBlockEvent): void;
+    onEntityDamage(event: EntityDamageEvent): void;
+    onPlaceBlock(event: PlaceBlockEvent): void;
+  }
+
+
+  interface WorldGuardWorldListener extends AbstractListener {}
+  class WorldGuardWorldListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    initWorld(world: World): void;
+    onChunkLoad(event: ChunkLoadEvent): void;
+    onWorldLoad(event: WorldLoadEvent): void;
+  }
+
+
+  interface WorldGuardPlayerListener extends AbstractListener {}
+  class WorldGuardPlayerListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onItemHeldChange(event: PlayerItemHeldEvent): void;
+    onPlayerChat(event: AsyncPlayerChatEvent): void;
+    onPlayerCommandPreprocess(event: PlayerCommandPreprocessEvent): void;
+    onPlayerGameModeChange(event: PlayerGameModeChangeEvent): void;
+    onPlayerInteract(event: PlayerInteractEvent): void;
+    onPlayerJoin(event: PlayerJoinEvent): void;
+    onPlayerLogin(event: PlayerLoginEvent): void;
+    onPlayerRespawn(event: PlayerRespawnEvent): void;
+    onPlayerTeleport(event: PlayerTeleportEvent): void;
+  }
+
+
+  interface PlayerMoveListener extends AbstractListener {}
+  class PlayerMoveListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onEntityMount(event: EntityMountEvent): void;
+    onPlayerMove(event: PlayerMoveEvent): void;
+    onPlayerQuit(event: PlayerQuitEvent): void;
+    onPlayerRespawn(event: PlayerRespawnEvent): void;
+    onVehicleEnter(event: VehicleEnterEvent): void;
+    registerEvents(): void;
+  }
+
+
+  interface BlockedPotionsListener extends AbstractListener {}
+  class BlockedPotionsListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onItemInteract(event: UseItemEvent): void;
+    onProjectile(event: DamageEntityEvent): void;
+  }
+
+
+  interface WorldGuardVehicleListener extends AbstractListener {}
+  class WorldGuardVehicleListener extends AbstractListener {
+    constructor(plugin: WorldGuardPlugin);
+    onVehicleMove(event: VehicleMoveEvent): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.listener.debounce.legacy' {
+  import { Entry } from 'com.sk89q.worldguard.bukkit.listener.debounce.legacy.AbstractEventDebounce';
+  import { Key } from 'com.sk89q.worldguard.bukkit.listener.debounce.legacy.BlockEntityEventDebounce';
+  import { Block } from 'org.bukkit.block';
+  import { Entity } from 'org.bukkit.entity';
+  import { Cancellable, Event } from 'org.bukkit.event';
+  import { Key as com_sk89q_worldguard_bukkit_listener_debounce_legacy_entityentityeventdebounce_Key } from 'com.sk89q.worldguard.bukkit.listener.debounce.legacy.EntityEntityEventDebounce';
+  import { Key as com_sk89q_worldguard_bukkit_listener_debounce_legacy_inventorymoveitemeventdebounce_Key } from 'com.sk89q.worldguard.bukkit.listener.debounce.legacy.InventoryMoveItemEventDebounce';
+  import { InventoryMoveItemEvent } from 'org.bukkit.event.inventory';
+
+  class AbstractEventDebounce<K = any> {
+    load(key: K): Entry;
+  }
+
+
+  interface BlockEntityEventDebounce extends AbstractEventDebounce<Key> {}
+  class BlockEntityEventDebounce extends AbstractEventDebounce<Key> {
+    constructor(debounceTime: number);
+    debounce<T extends Event & Cancellable>(block: Block, entity: Entity, originalEvent: Cancellable, firedEvent: T): void;
+  }
+
+
+  interface EntityEntityEventDebounce extends AbstractEventDebounce<com_sk89q_worldguard_bukkit_listener_debounce_legacy_entityentityeventdebounce_Key> {}
+  class EntityEntityEventDebounce extends AbstractEventDebounce<com_sk89q_worldguard_bukkit_listener_debounce_legacy_entityentityeventdebounce_Key> {
+    constructor(debounceTime: number);
+    debounce<T extends Event & Cancellable>(source: Entity, target: Entity, originalEvent: Cancellable, firedEvent: T): void;
+  }
+
+
+  interface InventoryMoveItemEventDebounce extends AbstractEventDebounce<com_sk89q_worldguard_bukkit_listener_debounce_legacy_inventorymoveitemeventdebounce_Key> {}
+  class InventoryMoveItemEventDebounce extends AbstractEventDebounce<com_sk89q_worldguard_bukkit_listener_debounce_legacy_inventorymoveitemeventdebounce_Key> {
+    constructor(debounceTime: number);
+    tryDebounce(event: InventoryMoveItemEvent): Entry;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.listener.debounce.legacy.AbstractEventDebounce' {
+  class Entry {
+    setCancelled(cancelled: boolean): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.listener.debounce' {
+  import { BlockPistonExtendEvent, BlockPistonRetractEvent } from 'org.bukkit.event.block';
+  import { Entry } from 'com.sk89q.worldguard.bukkit.listener.debounce.EventDebounce';
+  import { Cancellable, Event } from 'org.bukkit.event';
+
+  class BlockPistonExtendKey {
+    constructor(event: BlockPistonExtendEvent);
+    equals(o: any): boolean;
+    hashCode(): number;
+  }
+
+
+  class EventDebounce<K = any> {
+    constructor(debounceTime: number);
+    static create<K>(debounceTime: number): EventDebounce<K>;
+    fireToCancel<T extends Event & Cancellable>(originalEvent: Cancellable, firedEvent: T, key: K): void;
+    getIfNotPresent<T extends Event & Cancellable>(key: K, originalEvent: Cancellable): Entry;
+    load(key: K): Entry;
+  }
+
+
+  class BlockPistonRetractKey {
+    constructor(event: BlockPistonRetractEvent);
+    equals(o: any): boolean;
+    hashCode(): number;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.bukkit.listener.debounce.EventDebounce' {
+  class Entry {
+    setCancelled(cancelled: boolean): void;
+  }
+
+}
+
+declare module 'com.sk89q.worldguard.util.profile.resolver' {
+  import { Profile } from 'com.sk89q.worldguard.util.profile';
+  import { UUID } from 'java.util';
+
+  interface PaperProfileService extends SingleRequestService {}
+  class PaperProfileService extends SingleRequestService {
+    findByName(name: string): Profile;
+    findByUuid(uuid: UUID): Profile;
+    get idealRequestLimit(): number;
+    static get instance(): PaperProfileService;
+  }
+
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+// Auto generated index file, do not edit!
+
+/// <reference path="com_sk89q.d.ts" />

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@craftjs-typings/worldguard",
+  "version": "7.1.0",
+  "description": "WorldGuard TypeScript bindings",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/raikasdev/craftjs-types.git",
+    "directory": "packages/worldguard"
+  },
+  "author": "raikasdev",
+  "dependencies": {
+    "@craftjs-typings/java.base": "latest"
+  }
+}