refactor: 支持 Minecraft 1.21.1 版本

.probe/startup/probe-types/global/bindings.d.ts

@@ -0,0 +1,104 @@
+import {$RegistryWrapper, $RegistryWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.RegistryWrapper"
+import {$Stats, $Stats$$Type} from "net.minecraft.stats.Stats"
+import {$UUIDWrapper, $UUIDWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.UUIDWrapper"
+import {$NativeEventWrapper, $NativeEventWrapper$$Type} from "dev.latvian.mods.kubejs.neoforge.NativeEventWrapper"
+import {$FluidAmounts, $FluidAmounts$$Type} from "dev.latvian.mods.kubejs.util.FluidAmounts"
+import {$ID, $ID$$Type} from "dev.latvian.mods.kubejs.util.ID"
+import {$JsonIO, $JsonIO$$Type} from "dev.latvian.mods.kubejs.util.JsonIO"
+import {$Vector3f, $Vector3f$$Type} from "org.joml.Vector3f"
+import {$JavaWrapper, $JavaWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.JavaWrapper"
+import {$IngredientWrapper, $IngredientWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.IngredientWrapper"
+import {$AABBWrapper, $AABBWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.AABBWrapper"
+import {$BlockStatePredicate, $BlockStatePredicate$$Type} from "dev.latvian.mods.kubejs.block.state.BlockStatePredicate"
+import {$Matrix4f, $Matrix4f$$Type} from "org.joml.Matrix4f"
+import {$BlockWrapper, $BlockWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.BlockWrapper"
+import {$Math, $Math$$Type} from "java.lang.Math"
+import {$KMath, $KMath$$Type} from "dev.latvian.mods.kubejs.bindings.KMath"
+import {$ParticleOptionsWrapper, $ParticleOptionsWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.ParticleOptionsWrapper"
+import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
+import {$Vec3i, $Vec3i$$Type} from "net.minecraft.core.Vec3i"
+import {$Types, $Types$$Type} from "moe.wolfgirl.probejs.lang.typescript.code.type.Types"
+import {$NBTIOWrapper, $NBTIOWrapper$$Type} from "dev.latvian.mods.kubejs.util.NBTIOWrapper"
+import {$ColorWrapper, $ColorWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.ColorWrapper"
+import {$Minecraft, $Minecraft$$Type} from "net.minecraft.client.Minecraft"
+import {$TextWrapper, $TextWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.TextWrapper"
+import {$Quaternionf, $Quaternionf$$Type} from "org.joml.Quaternionf"
+import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
+import {$NotificationToastData, $NotificationToastData$$Type} from "dev.latvian.mods.kubejs.util.NotificationToastData"
+import {$Items, $Items$$Type} from "net.minecraft.world.item.Items"
+import {$JsonUtils, $JsonUtils$$Type} from "dev.latvian.mods.kubejs.util.JsonUtils"
+import {$NBTUtils, $NBTUtils$$Type} from "dev.latvian.mods.kubejs.util.NBTUtils"
+import {$PlatformWrapper, $PlatformWrapper$$Type} from "dev.latvian.mods.kubejs.script.PlatformWrapper"
+import {$SoundType, $SoundType$$Type} from "net.minecraft.world.level.block.SoundType"
+import {$Vector4f, $Vector4f$$Type} from "org.joml.Vector4f"
+import {$Probe, $Probe$$Type} from "moe.wolfgirl.probejs.plugin.Probe"
+import {$Blocks, $Blocks$$Type} from "net.minecraft.world.level.block.Blocks"
+import {$Duration, $Duration$$Type} from "java.time.Duration"
+import {$RotationAxis, $RotationAxis$$Type} from "dev.latvian.mods.kubejs.util.RotationAxis"
+import {$HashMap, $HashMap$$Type} from "java.util.HashMap"
+import {$Matrix3f, $Matrix3f$$Type} from "org.joml.Matrix3f"
+import {$UtilsWrapper, $UtilsWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.UtilsWrapper"
+import {$DirectionWrapper, $DirectionWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.DirectionWrapper"
+import {$ItemWrapper, $ItemWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.ItemWrapper"
+import {$TextIcons, $TextIcons$$Type} from "dev.latvian.mods.kubejs.bindings.TextIcons"
+import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
+import {$SizedIngredientWrapper, $SizedIngredientWrapper$$Type} from "dev.latvian.mods.kubejs.bindings.SizedIngredientWrapper"
+import {$BlockStateProperties, $BlockStateProperties$$Type} from "net.minecraft.world.level.block.state.properties.BlockStateProperties"
+import {$FluidWrapper, $FluidWrapper$$Type} from "dev.latvian.mods.kubejs.fluid.FluidWrapper"
+import {$ConsoleJS, $ConsoleJS$$Type} from "dev.latvian.mods.kubejs.script.ConsoleJS"
+
+declare global {
+const JavaMath: typeof $Math
+const Platform: typeof $PlatformWrapper
+const HOUR: long
+const global: $HashMap
+const RotationAxis: typeof $RotationAxis
+const Vec4f: typeof $Vector4f
+const Notification: typeof $NotificationToastData
+const Matrix3f: typeof $Matrix3f
+const Items: typeof $Items
+const MINUTE: long
+const BlockPos: typeof $BlockPos
+const BlockProperties: typeof $BlockStateProperties
+const Client: $Minecraft
+const SoundType: typeof $SoundType
+const console: $ConsoleJS
+const JsonIO: typeof $JsonIO
+const Vec3i: typeof $Vec3i
+const Blocks: typeof $Blocks
+const DamageSource: typeof $DamageSource
+const Quaternionf: typeof $Quaternionf
+const Duration: typeof $Duration
+const Registry: typeof $RegistryWrapper
+const Vec3f: typeof $Vector3f
+const Vec3d: typeof $Vec3
+const Matrix4f: typeof $Matrix4f
+const probejs: $Probe
+const Stats: typeof $Stats
+const Block: typeof $BlockWrapper
+const SECOND: long
+export import Java = $JavaWrapper
+export import NBT = $NBTUtils
+export import Types = $Types
+export import Facing = $DirectionWrapper
+export import ParticleOptions = $ParticleOptionsWrapper
+export import Fluid = $FluidWrapper
+export import Color = $ColorWrapper
+export import SizedIngredient = $SizedIngredientWrapper
+export import Text = $TextWrapper
+export import NBTIO = $NBTIOWrapper
+export import Direction = $DirectionWrapper
+export import TextIcons = $TextIcons
+export import Item = $ItemWrapper
+export import Utils = $UtilsWrapper
+export import JsonUtils = $JsonUtils
+export import Ingredient = $IngredientWrapper
+export import KMath = $KMath
+export import ID = $ID
+export import BlockStatePredicate = $BlockStatePredicate
+export import Component = $TextWrapper
+export import UUID = $UUIDWrapper
+export import NativeEvents = $NativeEventWrapper
+export import AABB = $AABBWrapper
+export import FluidAmounts = $FluidAmounts
+}

.probe/startup/probe-types/global/events.d.ts

@@ -0,0 +1,37 @@
+import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
+import {$ItemToolTierRegistryKubeEvent, $ItemToolTierRegistryKubeEvent$$Type} from "dev.latvian.mods.kubejs.item.custom.ItemToolTierRegistryKubeEvent"
+import {$KubeStartupEvent, $KubeStartupEvent$$Type} from "dev.latvian.mods.kubejs.event.KubeStartupEvent"
+import {$BlockModificationKubeEvent, $BlockModificationKubeEvent$$Type} from "dev.latvian.mods.kubejs.block.BlockModificationKubeEvent"
+import {$ItemModificationKubeEvent, $ItemModificationKubeEvent$$Type} from "dev.latvian.mods.kubejs.item.ItemModificationKubeEvent"
+import {$ItemModelPropertiesKubeEvent, $ItemModelPropertiesKubeEvent$$Type} from "dev.latvian.mods.kubejs.item.ItemModelPropertiesKubeEvent"
+import {$MenuScreenRegistryKubeEvent, $MenuScreenRegistryKubeEvent$$Type} from "dev.latvian.mods.kubejs.client.MenuScreenRegistryKubeEvent"
+import {$EntityRendererRegistryKubeEvent, $EntityRendererRegistryKubeEvent$$Type} from "dev.latvian.mods.kubejs.client.EntityRendererRegistryKubeEvent"
+import {$BlockEntityRendererRegistryKubeEvent, $BlockEntityRendererRegistryKubeEvent$$Type} from "dev.latvian.mods.kubejs.client.BlockEntityRendererRegistryKubeEvent"
+import {$CreativeTabKubeEvent, $CreativeTabKubeEvent$$Type} from "dev.latvian.mods.kubejs.item.creativetab.CreativeTabKubeEvent"
+
+declare global {
+export namespace ItemEvents {
+function modelProperties(handler: (event: $ItemModelPropertiesKubeEvent) => void): void
+/**
+ * Invoked after all items are registered to modify them.
+ */
+function modification(handler: (event: $ItemModificationKubeEvent) => void): void
+/**
+ * Invoked when the game is starting up and the item tool tiers are being registered.
+ */
+function toolTierRegistry(handler: (event: $ItemToolTierRegistryKubeEvent) => void): void
+}
+export namespace ClientEvents {
+function menuScreenRegistry(handler: (event: $MenuScreenRegistryKubeEvent) => void): void
+function entityRendererRegistry(handler: (event: $EntityRendererRegistryKubeEvent) => void): void
+function blockEntityRendererRegistry(handler: (event: $BlockEntityRendererRegistryKubeEvent) => void): void
+}
+export namespace StartupEvents {
+function init(handler: (event: $KubeStartupEvent) => void): void
+function modifyCreativeTab(extra: $ResourceLocation$$Type, handler: (event: $CreativeTabKubeEvent) => void): void
+function postInit(handler: (event: $KubeStartupEvent) => void): void
+}
+export namespace BlockEvents {
+function modification(handler: (event: $BlockModificationKubeEvent) => void): void
+}
+}

.probe/startup/probe-types/global/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./special_types"
+export * from "./primitives"
+export * from "./load_class"
+export * from "./registry_type"
+export * from "./registry_events"
+export * from "./bindings"
+export * from "./recipe_viewer_events"
+export * from "./events"

.probe/startup/probe-types/global/primitives.d.ts

@@ -0,0 +1,11 @@
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+declare global {
+export type long = (number) & (Number);
+export type integer = (number) & (Number);
+export type short = (number) & (Number);
+export type byte = (number) & (Number);
+export type double = (number) & (Number);
+export type float = (number) & (Number);
+interface character extends String {}
+interface charseq extends String {}
+}

.probe/startup/probe-types/global/recipe_viewer_events.d.ts

@@ -0,0 +1,5 @@
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+declare global {
+export namespace RecipeViewerEvents {
+}
+}

.probe/startup/probe-types/global/registry_events.d.ts

@@ -0,0 +1,35 @@
+import {$CreativeModeTab, $CreativeModeTab$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.CreativeModeTab"
+import {$ParticleType, $ParticleType$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.ParticleType"
+import {$Item, $Item$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.Item"
+import {$SoundEvent, $SoundEvent$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.SoundEvent"
+import {$Fluid, $Fluid$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.Fluid"
+import {$Block, $Block$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.Block"
+import {$MobEffect, $MobEffect$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.MobEffect"
+import {$ArmorMaterial, $ArmorMaterial$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.ArmorMaterial"
+import {$Attribute, $Attribute$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.Attribute"
+import {$Potion, $Potion$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.Potion"
+import {$FluidType, $FluidType$$Type} from "moe.wolfgirl.probejs.generated.registry.neoforge.FluidType"
+import {$VillagerProfession, $VillagerProfession$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.VillagerProfession"
+import {$VillagerType, $VillagerType$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.VillagerType"
+import {$PointOfInterestType, $PointOfInterestType$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.PointOfInterestType"
+import {$CustomStat, $CustomStat$$Type} from "moe.wolfgirl.probejs.generated.registry.minecraft.CustomStat"
+
+declare global {
+export namespace StartupEvents {
+function registry(type: "villager_profession", handler: (event: $VillagerProfession) => void): void
+function registry(type: "block", handler: (event: $Block) => void): void
+function registry(type: "mob_effect", handler: (event: $MobEffect) => void): void
+function registry(type: "attribute", handler: (event: $Attribute) => void): void
+function registry(type: "potion", handler: (event: $Potion) => void): void
+function registry(type: "creative_mode_tab", handler: (event: $CreativeModeTab) => void): void
+function registry(type: "custom_stat", handler: (event: $CustomStat) => void): void
+function registry(type: "neoforge:fluid_type", handler: (event: $FluidType) => void): void
+function registry(type: "point_of_interest_type", handler: (event: $PointOfInterestType) => void): void
+function registry(type: "fluid", handler: (event: $Fluid) => void): void
+function registry(type: "item", handler: (event: $Item) => void): void
+function registry(type: "villager_type", handler: (event: $VillagerType) => void): void
+function registry(type: "sound_event", handler: (event: $SoundEvent) => void): void
+function registry(type: "armor_material", handler: (event: $ArmorMaterial) => void): void
+function registry(type: "particle_type", handler: (event: $ParticleType) => void): void
+}
+}

.probe/startup/probe-types/packages/cpw.mods.d.ts

@@ -0,0 +1,88 @@
+declare module "cpw.mods.jarhandling.SecureJar$Status" {
+import {$Enum, $Enum$$Type} from "java.lang.Enum"
+
+export class $SecureJar$Status extends $Enum<($SecureJar$Status)> {
+static readonly "UNVERIFIED": $SecureJar$Status
+static readonly "NONE": $SecureJar$Status
+static readonly "INVALID": $SecureJar$Status
+static readonly "VERIFIED": $SecureJar$Status
+
+
+public static "values"(): ($SecureJar$Status)[]
+public static "valueOf"(arg0: string): $SecureJar$Status
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $SecureJar$Status$$Type = (("none") | ("invalid") | ("unverified") | ("verified"));
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $SecureJar$Status_ = $SecureJar$Status$$Type;
+}}
+declare module "cpw.mods.jarhandling.SecureJar" {
+import {$Attributes, $Attributes$$Type} from "java.util.jar.Attributes"
+import {$JarContents, $JarContents$$Type} from "cpw.mods.jarhandling.JarContents"
+import {$SecureJar$ModuleDataProvider, $SecureJar$ModuleDataProvider$$Type} from "cpw.mods.jarhandling.SecureJar$ModuleDataProvider"
+import {$SecureJar$Status, $SecureJar$Status$$Type} from "cpw.mods.jarhandling.SecureJar$Status"
+import {$JarMetadata, $JarMetadata$$Type} from "cpw.mods.jarhandling.JarMetadata"
+import {$Path, $Path$$Type} from "java.nio.file.Path"
+import {$CodeSigner, $CodeSigner$$Type} from "java.security.CodeSigner"
+
+export interface $SecureJar {
+
+ "getTrustedManifestEntries"(arg0: string): $Attributes
+ "moduleDataProvider"(): $SecureJar$ModuleDataProvider
+ "hasSecurityData"(): boolean
+ "getFileStatus"(arg0: string): $SecureJar$Status
+ "getPrimaryPath"(): $Path
+ "getManifestSigners"(): ($CodeSigner)[]
+ "getRootPath"(): $Path
+ "verifyPath"(arg0: $Path$$Type): $SecureJar$Status
+ "name"(): string
+ "close"(): void
+ "getPath"(arg0: string, ...arg1: (string)[]): $Path
+get "primaryPath"(): $Path
+get "manifestSigners"(): ($CodeSigner)[]
+get "rootPath"(): $Path
+}
+
+export namespace $SecureJar {
+function from(...arg0: ($Path$$Type)[]): $SecureJar
+function from(arg0: $JarContents$$Type, arg1: $JarMetadata$$Type): $SecureJar
+function from(arg0: $JarContents$$Type): $SecureJar
+const probejs$$marker: never
+}
+export class $SecureJar$$Static implements $SecureJar {
+
+
+ "getTrustedManifestEntries"(arg0: string): $Attributes
+ "moduleDataProvider"(): $SecureJar$ModuleDataProvider
+ "hasSecurityData"(): boolean
+ "getFileStatus"(arg0: string): $SecureJar$Status
+ "getPrimaryPath"(): $Path
+ "getManifestSigners"(): ($CodeSigner)[]
+ "getRootPath"(): $Path
+ "verifyPath"(arg0: $Path$$Type): $SecureJar$Status
+ "name"(): string
+static "from"(...arg0: ($Path$$Type)[]): $SecureJar
+static "from"(arg0: $JarContents$$Type, arg1: $JarMetadata$$Type): $SecureJar
+static "from"(arg0: $JarContents$$Type): $SecureJar
+ "close"(): void
+ "getPath"(arg0: string, ...arg1: (string)[]): $Path
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $SecureJar$$Type = ($SecureJar);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $SecureJar_ = $SecureJar$$Type;
+}}

.probe/startup/probe-types/packages/index.d.ts

@@ -0,0 +1,28 @@
+/// <reference path="javax.crypto.d.ts" />
+/// <reference path="com.mojang.d.ts" />
+/// <reference path="java.util.d.ts" />
+/// <reference path="org.slf4j.d.ts" />
+/// <reference path="com.electronwill.d.ts" />
+/// <reference path="javax.security.d.ts" />
+/// <reference path="org.joml.d.ts" />
+/// <reference path="org.spongepowered.d.ts" />
+/// <reference path="java.nio.d.ts" />
+/// <reference path="net.neoforged.d.ts" />
+/// <reference path="java.time.d.ts" />
+/// <reference path="moe.wolfgirl.d.ts" />
+/// <reference path="java.net.d.ts" />
+/// <reference path="it.unimi.d.ts" />
+/// <reference path="java.math.d.ts" />
+/// <reference path="javax.sound.d.ts" />
+/// <reference path="java.security.d.ts" />
+/// <reference path="com.google.d.ts" />
+/// <reference path="org.lwjgl.d.ts" />
+/// <reference path="cpw.mods.d.ts" />
+/// <reference path="java.awt.d.ts" />
+/// <reference path="io.netty.d.ts" />
+/// <reference path="java.text.d.ts" />
+/// <reference path="java.lang.d.ts" />
+/// <reference path="java.io.d.ts" />
+/// <reference path="dev.latvian.d.ts" />
+/// <reference path="net.minecraft.d.ts" />
+/// <reference path="org.apache.d.ts" />

.probe/startup/probe-types/packages/java.math.d.ts

@@ -0,0 +1,306 @@
+declare module "java.math.RoundingMode" {
+import {$Enum, $Enum$$Type} from "java.lang.Enum"
+
+export class $RoundingMode extends $Enum<($RoundingMode)> {
+static readonly "DOWN": $RoundingMode
+static readonly "FLOOR": $RoundingMode
+static readonly "UNNECESSARY": $RoundingMode
+static readonly "CEILING": $RoundingMode
+static readonly "HALF_EVEN": $RoundingMode
+static readonly "UP": $RoundingMode
+static readonly "HALF_UP": $RoundingMode
+static readonly "HALF_DOWN": $RoundingMode
+
+
+public static "values"(): ($RoundingMode)[]
+public static "valueOf"(arg0: string): $RoundingMode
+public static "valueOf"(arg0: integer): $RoundingMode
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $RoundingMode$$Type = (("up") | ("down") | ("ceiling") | ("floor") | ("half_up") | ("half_down") | ("half_even") | ("unnecessary"));
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $RoundingMode_ = $RoundingMode$$Type;
+}}
+declare module "java.math.BigDecimal" {
+import {$BigInteger, $BigInteger$$Type} from "java.math.BigInteger"
+import {$Comparable, $Comparable$$Type} from "java.lang.Comparable"
+import {$MathContext, $MathContext$$Type} from "java.math.MathContext"
+import {$RoundingMode, $RoundingMode$$Type} from "java.math.RoundingMode"
+
+export class $BigDecimal extends number implements $Comparable<($BigDecimal)> {
+static readonly "ZERO": $BigDecimal
+/**
+ * 
+ * @deprecated
+ */
+static readonly "ROUND_DOWN": integer
+/**
+ * 
+ * @deprecated
+ */
+static readonly "ROUND_UNNECESSARY": integer
+/**
+ * 
+ * @deprecated
+ */
+static readonly "ROUND_CEILING": integer
+/**
+ * 
+ * @deprecated
+ */
+static readonly "ROUND_HALF_DOWN": integer
+/**
+ * 
+ * @deprecated
+ */
+static readonly "ROUND_HALF_UP": integer
+static readonly "ONE": $BigDecimal
+/**
+ * 
+ * @deprecated
+ */
+static readonly "ROUND_UP": integer
+/**
+ * 
+ * @deprecated
+ */
+static readonly "ROUND_FLOOR": integer
+/**
+ * 
+ * @deprecated
+ */
+static readonly "ROUND_HALF_EVEN": integer
+static readonly "TEN": $BigDecimal
+static readonly "TWO": $BigDecimal
+
+constructor(arg0: $BigInteger$$Type, arg1: integer)
+constructor(arg0: $BigInteger$$Type, arg1: $MathContext$$Type)
+constructor(arg0: $BigInteger$$Type)
+constructor(arg0: long, arg1: $MathContext$$Type)
+constructor(arg0: double, arg1: $MathContext$$Type)
+constructor(arg0: long)
+constructor(arg0: integer, arg1: $MathContext$$Type)
+constructor(arg0: integer)
+constructor(arg0: $BigInteger$$Type, arg1: integer, arg2: $MathContext$$Type)
+constructor(arg0: (character)[])
+constructor(arg0: (character)[], arg1: integer, arg2: integer, arg3: $MathContext$$Type)
+constructor(arg0: (character)[], arg1: integer, arg2: integer)
+constructor(arg0: double)
+constructor(arg0: string, arg1: $MathContext$$Type)
+constructor(arg0: string)
+constructor(arg0: (character)[], arg1: $MathContext$$Type)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "abs"(): $BigDecimal
+public "abs"(arg0: $MathContext$$Type): $BigDecimal
+public "sqrt"(arg0: $MathContext$$Type): $BigDecimal
+public "pow"(arg0: integer): $BigDecimal
+public "pow"(arg0: integer, arg1: $MathContext$$Type): $BigDecimal
+public "min"(arg0: $BigDecimal$$Type): $BigDecimal
+public "max"(arg0: $BigDecimal$$Type): $BigDecimal
+public "round"(arg0: $MathContext$$Type): $BigDecimal
+public "signum"(): integer
+public "compareTo"(arg0: $BigDecimal$$Type): integer
+public "compareTo"(arg0: any): integer
+public "intValue"(): integer
+public "longValue"(): long
+public "floatValue"(): float
+public "doubleValue"(): double
+public static "valueOf"(arg0: double): $BigDecimal
+public static "valueOf"(arg0: long): $BigDecimal
+public static "valueOf"(arg0: long, arg1: integer): $BigDecimal
+public "scale"(): integer
+public "add"(arg0: $BigDecimal$$Type): $BigDecimal
+public "add"(arg0: $BigDecimal$$Type, arg1: $MathContext$$Type): $BigDecimal
+public "multiply"(arg0: $BigDecimal$$Type): $BigDecimal
+public "multiply"(arg0: $BigDecimal$$Type, arg1: $MathContext$$Type): $BigDecimal
+public "ulp"(): $BigDecimal
+public "remainder"(arg0: $BigDecimal$$Type): $BigDecimal
+public "remainder"(arg0: $BigDecimal$$Type, arg1: $MathContext$$Type): $BigDecimal
+public "subtract"(arg0: $BigDecimal$$Type, arg1: $MathContext$$Type): $BigDecimal
+public "subtract"(arg0: $BigDecimal$$Type): $BigDecimal
+public "negate"(arg0: $MathContext$$Type): $BigDecimal
+public "negate"(): $BigDecimal
+public "toBigInteger"(): $BigInteger
+/**
+ * 
+ * @deprecated
+ */
+public "divide"(arg0: $BigDecimal$$Type, arg1: integer, arg2: integer): $BigDecimal
+public "divide"(arg0: $BigDecimal$$Type, arg1: $MathContext$$Type): $BigDecimal
+public "divide"(arg0: $BigDecimal$$Type, arg1: integer, arg2: $RoundingMode$$Type): $BigDecimal
+/**
+ * 
+ * @deprecated
+ */
+public "divide"(arg0: $BigDecimal$$Type, arg1: integer): $BigDecimal
+public "divide"(arg0: $BigDecimal$$Type, arg1: $RoundingMode$$Type): $BigDecimal
+public "divide"(arg0: $BigDecimal$$Type): $BigDecimal
+public "divideAndRemainder"(arg0: $BigDecimal$$Type): ($BigDecimal)[]
+public "divideAndRemainder"(arg0: $BigDecimal$$Type, arg1: $MathContext$$Type): ($BigDecimal)[]
+public "longValueExact"(): long
+public "intValueExact"(): integer
+public "shortValueExact"(): short
+public "byteValueExact"(): byte
+public "scaleByPowerOfTen"(arg0: integer): $BigDecimal
+public "plus"(): $BigDecimal
+public "plus"(arg0: $MathContext$$Type): $BigDecimal
+public "divideToIntegralValue"(arg0: $BigDecimal$$Type, arg1: $MathContext$$Type): $BigDecimal
+public "divideToIntegralValue"(arg0: $BigDecimal$$Type): $BigDecimal
+public "movePointRight"(arg0: integer): $BigDecimal
+public "toBigIntegerExact"(): $BigInteger
+public "precision"(): integer
+public "unscaledValue"(): $BigInteger
+public "setScale"(arg0: integer): $BigDecimal
+/**
+ * 
+ * @deprecated
+ */
+public "setScale"(arg0: integer, arg1: integer): $BigDecimal
+public "setScale"(arg0: integer, arg1: $RoundingMode$$Type): $BigDecimal
+public "movePointLeft"(arg0: integer): $BigDecimal
+public "toEngineeringString"(): string
+public "toPlainString"(): string
+public "stripTrailingZeros"(): $BigDecimal
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $BigDecimal$$Type = ($BigDecimal);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $BigDecimal_ = $BigDecimal$$Type;
+}}
+declare module "java.math.MathContext" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$RoundingMode, $RoundingMode$$Type} from "java.math.RoundingMode"
+
+export class $MathContext implements $Serializable {
+static readonly "DECIMAL128": $MathContext
+static readonly "DECIMAL64": $MathContext
+static readonly "DECIMAL32": $MathContext
+static readonly "UNLIMITED": $MathContext
+
+constructor(arg0: string)
+constructor(arg0: integer, arg1: $RoundingMode$$Type)
+constructor(arg0: integer)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getRoundingMode"(): $RoundingMode
+public "getPrecision"(): integer
+get "roundingMode"(): $RoundingMode
+get "precision"(): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $MathContext$$Type = ($MathContext);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $MathContext_ = $MathContext$$Type;
+}}
+declare module "java.math.BigInteger" {
+import {$Comparable, $Comparable$$Type} from "java.lang.Comparable"
+import {$Random, $Random$$Type} from "java.util.Random"
+
+export class $BigInteger extends number implements $Comparable<($BigInteger)> {
+static readonly "ZERO": $BigInteger
+static readonly "ONE": $BigInteger
+static readonly "TEN": $BigInteger
+static readonly "TWO": $BigInteger
+
+constructor(arg0: integer, arg1: $Random$$Type)
+constructor(arg0: string)
+constructor(arg0: integer, arg1: integer, arg2: $Random$$Type)
+constructor(arg0: integer, arg1: (byte)[], arg2: integer, arg3: integer)
+constructor(arg0: (byte)[])
+constructor(arg0: (byte)[], arg1: integer, arg2: integer)
+constructor(arg0: string, arg1: integer)
+constructor(arg0: integer, arg1: (byte)[])
+
+public "bitCount"(): integer
+public "equals"(arg0: any): boolean
+public "toString"(arg0: integer): string
+public "toString"(): string
+public "hashCode"(): integer
+public "abs"(): $BigInteger
+public "sqrt"(): $BigInteger
+public "pow"(arg0: integer): $BigInteger
+public "min"(arg0: $BigInteger$$Type): $BigInteger
+public "max"(arg0: $BigInteger$$Type): $BigInteger
+public "signum"(): integer
+public "compareTo"(arg0: $BigInteger$$Type): integer
+public "compareTo"(arg0: any): integer
+public "intValue"(): integer
+public "longValue"(): long
+public "floatValue"(): float
+public "doubleValue"(): double
+public static "valueOf"(arg0: long): $BigInteger
+public "add"(arg0: $BigInteger$$Type): $BigInteger
+public "mod"(arg0: $BigInteger$$Type): $BigInteger
+public "setBit"(arg0: integer): $BigInteger
+public "shiftLeft"(arg0: integer): $BigInteger
+public "multiply"(arg0: $BigInteger$$Type): $BigInteger
+public "or"(arg0: $BigInteger$$Type): $BigInteger
+public "toByteArray"(): (byte)[]
+public "remainder"(arg0: $BigInteger$$Type): $BigInteger
+public "bitLength"(): integer
+public "testBit"(arg0: integer): boolean
+public "subtract"(arg0: $BigInteger$$Type): $BigInteger
+public "shiftRight"(arg0: integer): $BigInteger
+public "getLowestSetBit"(): integer
+public "modPow"(arg0: $BigInteger$$Type, arg1: $BigInteger$$Type): $BigInteger
+public "negate"(): $BigInteger
+public "modInverse"(arg0: $BigInteger$$Type): $BigInteger
+public "divide"(arg0: $BigInteger$$Type): $BigInteger
+public "divideAndRemainder"(arg0: $BigInteger$$Type): ($BigInteger)[]
+public static "probablePrime"(arg0: integer, arg1: $Random$$Type): $BigInteger
+public "nextProbablePrime"(): $BigInteger
+public "parallelMultiply"(arg0: $BigInteger$$Type): $BigInteger
+public "sqrtAndRemainder"(): ($BigInteger)[]
+public "gcd"(arg0: $BigInteger$$Type): $BigInteger
+public "and"(arg0: $BigInteger$$Type): $BigInteger
+public "xor"(arg0: $BigInteger$$Type): $BigInteger
+public "not"(): $BigInteger
+public "andNot"(arg0: $BigInteger$$Type): $BigInteger
+public "clearBit"(arg0: integer): $BigInteger
+public "flipBit"(arg0: integer): $BigInteger
+public "isProbablePrime"(arg0: integer): boolean
+public "longValueExact"(): long
+public "intValueExact"(): integer
+public "shortValueExact"(): short
+public "byteValueExact"(): byte
+set "bit"(value: integer)
+get "lowestSetBit"(): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $BigInteger$$Type = ($BigInteger);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $BigInteger_ = $BigInteger$$Type;
+}}

.probe/startup/probe-types/packages/java.security.d.ts

@@ -0,0 +1,906 @@
+declare module "java.security.Key" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+
+export interface $Key extends $Serializable {
+
+ "getEncoded"(): (byte)[]
+ "getFormat"(): string
+ "getAlgorithm"(): string
+get "encoded"(): (byte)[]
+get "format"(): string
+get "algorithm"(): string
+}
+
+export namespace $Key {
+const serialVersionUID: long
+const probejs$$marker: never
+}
+export class $Key$$Static implements $Key {
+/**
+ * 
+ * @deprecated
+ */
+static readonly "serialVersionUID": long
+
+
+ "getEncoded"(): (byte)[]
+ "getFormat"(): string
+ "getAlgorithm"(): string
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Key$$Type = ($Key);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Key_ = $Key$$Type;
+}}
+declare module "java.security.Principal" {
+import {$Subject, $Subject$$Type} from "javax.security.auth.Subject"
+
+export interface $Principal {
+
+ "getName"(): string
+ "equals"(arg0: any): boolean
+ "toString"(): string
+ "hashCode"(): integer
+ "implies"(arg0: $Subject$$Type): boolean
+get "name"(): string
+}
+
+export namespace $Principal {
+const probejs$$marker: never
+}
+export class $Principal$$Static implements $Principal {
+
+
+ "getName"(): string
+ "equals"(arg0: any): boolean
+ "toString"(): string
+ "hashCode"(): integer
+ "implies"(arg0: $Subject$$Type): boolean
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Principal$$Type = ($Principal);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Principal_ = $Principal$$Type;
+}}
+declare module "java.security.PrivateKey" {
+import {$Destroyable, $Destroyable$$Type} from "javax.security.auth.Destroyable"
+import {$Key, $Key$$Type} from "java.security.Key"
+
+export interface $PrivateKey extends $Key, $Destroyable {
+
+ "getEncoded"(): (byte)[]
+ "getFormat"(): string
+ "getAlgorithm"(): string
+ "isDestroyed"(): boolean
+ "destroy"(): void
+get "encoded"(): (byte)[]
+get "format"(): string
+get "algorithm"(): string
+get "destroyed"(): boolean
+}
+
+export namespace $PrivateKey {
+const serialVersionUID: long
+const probejs$$marker: never
+}
+export class $PrivateKey$$Static implements $PrivateKey {
+/**
+ * 
+ * @deprecated
+ */
+static readonly "serialVersionUID": long
+
+
+ "getEncoded"(): (byte)[]
+ "getFormat"(): string
+ "getAlgorithm"(): string
+ "isDestroyed"(): boolean
+ "destroy"(): void
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $PrivateKey$$Type = ($PrivateKey);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $PrivateKey_ = $PrivateKey$$Type;
+}}
+declare module "java.security.cert.Certificate" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$Provider, $Provider$$Type} from "java.security.Provider"
+import {$PublicKey, $PublicKey$$Type} from "java.security.PublicKey"
+
+export class $Certificate implements $Serializable {
+
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getType"(): string
+public "getEncoded"(): (byte)[]
+public "verify"(arg0: $PublicKey$$Type): void
+public "verify"(arg0: $PublicKey$$Type, arg1: string): void
+public "verify"(arg0: $PublicKey$$Type, arg1: $Provider$$Type): void
+public "getPublicKey"(): $PublicKey
+get "type"(): string
+get "encoded"(): (byte)[]
+get "publicKey"(): $PublicKey
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Certificate$$Type = ($Certificate);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Certificate_ = $Certificate$$Type;
+}}
+declare module "java.security.AlgorithmParameters" {
+import {$Provider, $Provider$$Type} from "java.security.Provider"
+import {$Class, $Class$$Type} from "java.lang.Class"
+import {$AlgorithmParameterSpec, $AlgorithmParameterSpec$$Type} from "java.security.spec.AlgorithmParameterSpec"
+
+export class $AlgorithmParameters {
+
+
+public "toString"(): string
+public static "getInstance"(arg0: string, arg1: $Provider$$Type): $AlgorithmParameters
+public static "getInstance"(arg0: string, arg1: string): $AlgorithmParameters
+public static "getInstance"(arg0: string): $AlgorithmParameters
+public "init"(arg0: (byte)[]): void
+public "init"(arg0: (byte)[], arg1: string): void
+public "init"(arg0: $AlgorithmParameterSpec$$Type): void
+public "getEncoded"(): (byte)[]
+public "getEncoded"(arg0: string): (byte)[]
+public "getProvider"(): $Provider
+public "getAlgorithm"(): string
+public "getParameterSpec"<T extends $AlgorithmParameterSpec>(arg0: $Class$$Type<(T)>): T
+get "encoded"(): (byte)[]
+get "provider"(): $Provider
+get "algorithm"(): string
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $AlgorithmParameters$$Type = ($AlgorithmParameters);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $AlgorithmParameters_ = $AlgorithmParameters$$Type;
+}}
+declare module "java.security.Guard" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $Guard {
+
+ "checkGuard"(arg0: any): void
+
+(arg0: any): void
+}
+
+export namespace $Guard {
+const probejs$$marker: never
+}
+export class $Guard$$Static implements $Guard {
+
+
+ "checkGuard"(arg0: any): void
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Guard$$Type = ((arg0: any) => void);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Guard_ = $Guard$$Type;
+}}
+declare module "java.security.Provider" {
+import {$BiFunction, $BiFunction$$Type} from "java.util.function.BiFunction"
+import {$Provider$Service, $Provider$Service$$Type} from "java.security.Provider$Service"
+import {$Collection, $Collection$$Type} from "java.util.Collection"
+import {$Map, $Map$$Type} from "java.util.Map"
+import {$Properties, $Properties$$Type} from "java.util.Properties"
+import {$Function, $Function$$Type} from "java.util.function.Function"
+import {$BiConsumer, $BiConsumer$$Type} from "java.util.function.BiConsumer"
+import {$Set, $Set$$Type} from "java.util.Set"
+import {$InputStream, $InputStream$$Type} from "java.io.InputStream"
+import {$Enumeration, $Enumeration$$Type} from "java.util.Enumeration"
+import {$Map$Entry, $Map$Entry$$Type} from "java.util.Map$Entry"
+
+export class $Provider extends $Properties {
+
+
+public "getName"(): string
+public "remove"(arg0: any): any
+public "remove"(arg0: any, arg1: any): boolean
+public "get"(arg0: any): any
+public "put"(arg0: any, arg1: any): any
+public "getProperty"(arg0: string): string
+public "toString"(): string
+public "values"(): $Collection<(any)>
+public "load"(arg0: $InputStream$$Type): void
+public "clear"(): void
+public "replace"(arg0: any, arg1: any): any
+public "replace"(arg0: any, arg1: any, arg2: any): boolean
+public "replaceAll"(arg0: $BiFunction$$Type<(any), (any), (any)>): void
+public "elements"(): $Enumeration<(any)>
+public "merge"(arg0: any, arg1: any, arg2: $BiFunction$$Type<(any), (any), (any)>): any
+public "entrySet"(): $Set<($Map$Entry<(any), (any)>)>
+public "putAll"(arg0: $Map$$Type<(any), (any)>): void
+public "putIfAbsent"(arg0: any, arg1: any): any
+public "compute"(arg0: any, arg1: $BiFunction$$Type<(any), (any), (any)>): any
+public "forEach"(arg0: $BiConsumer$$Type<(any), (any)>): void
+public "computeIfAbsent"(arg0: any, arg1: $Function$$Type<(any), (any)>): any
+public "keys"(): $Enumeration<(any)>
+public "keySet"(): $Set<(any)>
+public "getOrDefault"(arg0: any, arg1: any): any
+public "computeIfPresent"(arg0: any, arg1: $BiFunction$$Type<(any), (any), (any)>): any
+/**
+ * 
+ * @deprecated
+ */
+public "getVersion"(): double
+public "getService"(arg0: string, arg1: string): $Provider$Service
+public "configure"(arg0: string): $Provider
+public "isConfigured"(): boolean
+public "getVersionStr"(): string
+public "getInfo"(): string
+public "getServices"(): $Set<($Provider$Service)>
+public static "copyOf"<K, V>(arg0: $Map$$Type<(K), (V)>): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V, arg4: K, arg5: V, arg6: K, arg7: V): $Map<(K), (V)>
+public static "of"<K, V>(): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V, arg4: K, arg5: V): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V, arg4: K, arg5: V, arg6: K, arg7: V, arg8: K, arg9: V, arg10: K, arg11: V, arg12: K, arg13: V, arg14: K, arg15: V, arg16: K, arg17: V, arg18: K, arg19: V): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V, arg4: K, arg5: V, arg6: K, arg7: V, arg8: K, arg9: V, arg10: K, arg11: V, arg12: K, arg13: V, arg14: K, arg15: V, arg16: K, arg17: V): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V, arg4: K, arg5: V, arg6: K, arg7: V, arg8: K, arg9: V, arg10: K, arg11: V, arg12: K, arg13: V, arg14: K, arg15: V): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V, arg4: K, arg5: V, arg6: K, arg7: V, arg8: K, arg9: V, arg10: K, arg11: V, arg12: K, arg13: V): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V, arg4: K, arg5: V, arg6: K, arg7: V, arg8: K, arg9: V, arg10: K, arg11: V): $Map<(K), (V)>
+public static "of"<K, V>(arg0: K, arg1: V, arg2: K, arg3: V, arg4: K, arg5: V, arg6: K, arg7: V, arg8: K, arg9: V): $Map<(K), (V)>
+public static "entry"<K, V>(arg0: K, arg1: V): $Map$Entry<(K), (V)>
+public static "ofEntries"<K, V>(...arg0: ($Map$Entry$$Type<(K), (V)>)[]): $Map<(K), (V)>
+get "name"(): string
+get "version"(): double
+get "configured"(): boolean
+get "versionStr"(): string
+get "info"(): string
+get "services"(): $Set<($Provider$Service)>
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Provider$$Type = ($Provider);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Provider_ = $Provider$$Type;
+}}
+declare module "java.security.SecureRandom" {
+import {$RandomGenerator, $RandomGenerator$$Type} from "java.util.random.RandomGenerator"
+import {$Provider, $Provider$$Type} from "java.security.Provider"
+import {$Random, $Random$$Type} from "java.util.Random"
+import {$SecureRandomParameters, $SecureRandomParameters$$Type} from "java.security.SecureRandomParameters"
+
+export class $SecureRandom extends $Random {
+
+constructor(arg0: (byte)[])
+constructor()
+
+public "toString"(): string
+public static "getInstance"(arg0: string, arg1: $SecureRandomParameters$$Type, arg2: string): $SecureRandom
+public static "getInstance"(arg0: string, arg1: $SecureRandomParameters$$Type): $SecureRandom
+public static "getInstance"(arg0: string, arg1: $SecureRandomParameters$$Type, arg2: $Provider$$Type): $SecureRandom
+public static "getInstance"(arg0: string): $SecureRandom
+public static "getInstance"(arg0: string, arg1: string): $SecureRandom
+public static "getInstance"(arg0: string, arg1: $Provider$$Type): $SecureRandom
+public "getParameters"(): $SecureRandomParameters
+public "nextBytes"(arg0: (byte)[]): void
+public "nextBytes"(arg0: (byte)[], arg1: $SecureRandomParameters$$Type): void
+public "getProvider"(): $Provider
+public "setSeed"(arg0: long): void
+public "setSeed"(arg0: (byte)[]): void
+public static "getSeed"(arg0: integer): (byte)[]
+public "getAlgorithm"(): string
+public "generateSeed"(arg0: integer): (byte)[]
+public static "getInstanceStrong"(): $SecureRandom
+public "reseed"(arg0: $SecureRandomParameters$$Type): void
+public "reseed"(): void
+public static "getDefault"(): $RandomGenerator
+public static "of"(arg0: string): $RandomGenerator
+get "parameters"(): $SecureRandomParameters
+get "provider"(): $Provider
+set "seed"(value: long)
+set "seed"(value: (byte)[])
+get "algorithm"(): string
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $SecureRandom$$Type = ($SecureRandom);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $SecureRandom_ = $SecureRandom$$Type;
+}}
+declare module "java.security.Provider$Service" {
+import {$Map, $Map$$Type} from "java.util.Map"
+import {$List, $List$$Type} from "java.util.List"
+import {$Provider, $Provider$$Type} from "java.security.Provider"
+
+export class $Provider$Service {
+
+constructor(arg0: $Provider$$Type, arg1: string, arg2: string, arg3: string, arg4: $List$$Type<(string)>, arg5: $Map$$Type<(string), (string)>)
+
+public "toString"(): string
+public "newInstance"(arg0: any): any
+public "getType"(): string
+public "getClassName"(): string
+public "getAttribute"(arg0: string): string
+public "getProvider"(): $Provider
+public "getAlgorithm"(): string
+public "supportsParameter"(arg0: any): boolean
+get "type"(): string
+get "className"(): string
+get "provider"(): $Provider
+get "algorithm"(): string
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Provider$Service$$Type = ($Provider$Service);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Provider$Service_ = $Provider$Service$$Type;
+}}
+declare module "java.security.Signature" {
+import {$Certificate, $Certificate$$Type} from "java.security.cert.Certificate"
+import {$PrivateKey, $PrivateKey$$Type} from "java.security.PrivateKey"
+import {$Provider, $Provider$$Type} from "java.security.Provider"
+import {$AlgorithmParameters, $AlgorithmParameters$$Type} from "java.security.AlgorithmParameters"
+import {$PublicKey, $PublicKey$$Type} from "java.security.PublicKey"
+import {$SecureRandom, $SecureRandom$$Type} from "java.security.SecureRandom"
+import {$ByteBuffer, $ByteBuffer$$Type} from "java.nio.ByteBuffer"
+import {$SignatureSpi, $SignatureSpi$$Type} from "java.security.SignatureSpi"
+import {$AlgorithmParameterSpec, $AlgorithmParameterSpec$$Type} from "java.security.spec.AlgorithmParameterSpec"
+
+export class $Signature extends $SignatureSpi {
+
+
+public "toString"(): string
+public "clone"(): any
+public "update"(arg0: (byte)[]): void
+public "update"(arg0: (byte)[], arg1: integer, arg2: integer): void
+public "update"(arg0: byte): void
+public "update"(arg0: $ByteBuffer$$Type): void
+public static "getInstance"(arg0: string): $Signature
+public static "getInstance"(arg0: string, arg1: string): $Signature
+public static "getInstance"(arg0: string, arg1: $Provider$$Type): $Signature
+public "getParameters"(): $AlgorithmParameters
+public "sign"(arg0: (byte)[], arg1: integer, arg2: integer): integer
+public "sign"(): (byte)[]
+public "verify"(arg0: (byte)[], arg1: integer, arg2: integer): boolean
+public "verify"(arg0: (byte)[]): boolean
+public "getProvider"(): $Provider
+public "getAlgorithm"(): string
+/**
+ * 
+ * @deprecated
+ */
+public "getParameter"(arg0: string): any
+public "initVerify"(arg0: $Certificate$$Type): void
+public "initVerify"(arg0: $PublicKey$$Type): void
+public "initSign"(arg0: $PrivateKey$$Type): void
+public "initSign"(arg0: $PrivateKey$$Type, arg1: $SecureRandom$$Type): void
+/**
+ * 
+ * @deprecated
+ */
+public "setParameter"(arg0: string, arg1: any): void
+public "setParameter"(arg0: $AlgorithmParameterSpec$$Type): void
+get "parameters"(): $AlgorithmParameters
+get "provider"(): $Provider
+get "algorithm"(): string
+set "parameter"(value: $AlgorithmParameterSpec$$Type)
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Signature$$Type = ($Signature);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Signature_ = $Signature$$Type;
+}}
+declare module "java.security.ProtectionDomain" {
+import {$Principal, $Principal$$Type} from "java.security.Principal"
+import {$Permission, $Permission$$Type} from "java.security.Permission"
+import {$PermissionCollection, $PermissionCollection$$Type} from "java.security.PermissionCollection"
+import {$CodeSource, $CodeSource$$Type} from "java.security.CodeSource"
+import {$ClassLoader, $ClassLoader$$Type} from "java.lang.ClassLoader"
+
+export class $ProtectionDomain {
+
+constructor(arg0: $CodeSource$$Type, arg1: $PermissionCollection$$Type)
+constructor(arg0: $CodeSource$$Type, arg1: $PermissionCollection$$Type, arg2: $ClassLoader$$Type, arg3: ($Principal$$Type)[])
+
+public "toString"(): string
+public "getClassLoader"(): $ClassLoader
+public "getCodeSource"(): $CodeSource
+public "implies"(arg0: $Permission$$Type): boolean
+public "getPermissions"(): $PermissionCollection
+public "getPrincipals"(): ($Principal)[]
+public "staticPermissionsOnly"(): boolean
+get "classLoader"(): $ClassLoader
+get "codeSource"(): $CodeSource
+get "permissions"(): $PermissionCollection
+get "principals"(): ($Principal)[]
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $ProtectionDomain$$Type = ($ProtectionDomain);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $ProtectionDomain_ = $ProtectionDomain$$Type;
+}}
+declare module "java.security.KeyPair" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$PrivateKey, $PrivateKey$$Type} from "java.security.PrivateKey"
+import {$PublicKey, $PublicKey$$Type} from "java.security.PublicKey"
+
+export class $KeyPair implements $Serializable {
+
+constructor(arg0: $PublicKey$$Type, arg1: $PrivateKey$$Type)
+
+public "getPrivate"(): $PrivateKey
+public "getPublic"(): $PublicKey
+get "private"(): $PrivateKey
+get "public"(): $PublicKey
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $KeyPair$$Type = ($KeyPair);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $KeyPair_ = $KeyPair$$Type;
+}}
+declare module "java.security.SignatureSpi" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export class $SignatureSpi {
+
+constructor()
+
+public "clone"(): any
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $SignatureSpi$$Type = ($SignatureSpi);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $SignatureSpi_ = $SignatureSpi$$Type;
+}}
+declare module "java.security.CodeSource" {
+import {$Certificate, $Certificate$$Type} from "java.security.cert.Certificate"
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$URL, $URL$$Type} from "java.net.URL"
+import {$CodeSigner, $CodeSigner$$Type} from "java.security.CodeSigner"
+
+export class $CodeSource implements $Serializable {
+
+constructor(arg0: $URL$$Type, arg1: ($Certificate$$Type)[])
+constructor(arg0: $URL$$Type, arg1: ($CodeSigner$$Type)[])
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getLocation"(): $URL
+public "getCertificates"(): ($Certificate)[]
+public "implies"(arg0: $CodeSource$$Type): boolean
+public "getCodeSigners"(): ($CodeSigner)[]
+get "location"(): $URL
+get "certificates"(): ($Certificate)[]
+get "codeSigners"(): ($CodeSigner)[]
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $CodeSource$$Type = ($CodeSource);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $CodeSource_ = $CodeSource$$Type;
+}}
+declare module "java.security.PermissionCollection" {
+import {$Permission, $Permission$$Type} from "java.security.Permission"
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$Stream, $Stream$$Type} from "java.util.stream.Stream"
+import {$Enumeration, $Enumeration$$Type} from "java.util.Enumeration"
+
+export class $PermissionCollection implements $Serializable {
+
+constructor()
+
+public "toString"(): string
+public "add"(arg0: $Permission$$Type): void
+public "elements"(): $Enumeration<($Permission)>
+public "setReadOnly"(): void
+public "implies"(arg0: $Permission$$Type): boolean
+public "isReadOnly"(): boolean
+public "elementsAsStream"(): $Stream<($Permission)>
+get "readOnly"(): boolean
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $PermissionCollection$$Type = ($PermissionCollection);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $PermissionCollection_ = $PermissionCollection$$Type;
+}}
+declare module "java.security.spec.AlgorithmParameterSpec" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $AlgorithmParameterSpec {
+
+}
+
+export namespace $AlgorithmParameterSpec {
+const probejs$$marker: never
+}
+export class $AlgorithmParameterSpec$$Static implements $AlgorithmParameterSpec {
+
+
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $AlgorithmParameterSpec$$Type = ($AlgorithmParameterSpec);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $AlgorithmParameterSpec_ = $AlgorithmParameterSpec$$Type;
+}}
+declare module "java.security.cert.CertPath" {
+import {$Iterator, $Iterator$$Type} from "java.util.Iterator"
+import {$Certificate, $Certificate$$Type} from "java.security.cert.Certificate"
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$List, $List$$Type} from "java.util.List"
+
+export class $CertPath implements $Serializable {
+
+
+public "getEncodings"(): $Iterator<(string)>
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getCertificates"(): $List<($Certificate)>
+public "getType"(): string
+public "getEncoded"(arg0: string): (byte)[]
+public "getEncoded"(): (byte)[]
+get "encodings"(): $Iterator<(string)>
+get "certificates"(): $List<($Certificate)>
+get "type"(): string
+get "encoded"(): (byte)[]
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $CertPath$$Type = ($CertPath);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $CertPath_ = $CertPath$$Type;
+}}
+declare module "java.security.PrivilegedAction" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $PrivilegedAction<T> {
+
+ "run"(): T
+
+(): T
+}
+
+export namespace $PrivilegedAction {
+const probejs$$marker: never
+}
+export class $PrivilegedAction$$Static<T> implements $PrivilegedAction {
+
+
+ "run"(): T
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $PrivilegedAction$$Type<T> = (() => T);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $PrivilegedAction_<T> = $PrivilegedAction$$Type<(T)>;
+}}
+declare module "java.security.Timestamp" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$CertPath, $CertPath$$Type} from "java.security.cert.CertPath"
+import {$Date, $Date$$Type} from "java.util.Date"
+
+export class $Timestamp implements $Serializable {
+
+constructor(arg0: $Date$$Type, arg1: $CertPath$$Type)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getSignerCertPath"(): $CertPath
+public "getTimestamp"(): $Date
+get "signerCertPath"(): $CertPath
+get "timestamp"(): $Date
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Timestamp$$Type = ($Timestamp);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Timestamp_ = $Timestamp$$Type;
+}}
+declare module "java.security.PublicKey" {
+import {$Key, $Key$$Type} from "java.security.Key"
+
+export interface $PublicKey extends $Key {
+
+ "getEncoded"(): (byte)[]
+ "getFormat"(): string
+ "getAlgorithm"(): string
+get "encoded"(): (byte)[]
+get "format"(): string
+get "algorithm"(): string
+}
+
+export namespace $PublicKey {
+const serialVersionUID: long
+const probejs$$marker: never
+}
+export class $PublicKey$$Static implements $PublicKey {
+/**
+ * 
+ * @deprecated
+ */
+static readonly "serialVersionUID": long
+
+
+ "getEncoded"(): (byte)[]
+ "getFormat"(): string
+ "getAlgorithm"(): string
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $PublicKey$$Type = ($PublicKey);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $PublicKey_ = $PublicKey$$Type;
+}}
+declare module "java.security.Permission" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$PermissionCollection, $PermissionCollection$$Type} from "java.security.PermissionCollection"
+import {$Guard, $Guard$$Type} from "java.security.Guard"
+
+export class $Permission implements $Guard, $Serializable {
+
+constructor(arg0: string)
+
+public "getName"(): string
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "implies"(arg0: $Permission$$Type): boolean
+public "getActions"(): string
+public "newPermissionCollection"(): $PermissionCollection
+public "checkGuard"(arg0: any): void
+get "name"(): string
+get "actions"(): string
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Permission$$Type = ($Permission);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Permission_ = $Permission$$Type;
+}}
+declare module "java.security.SecureRandomParameters" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $SecureRandomParameters {
+
+}
+
+export namespace $SecureRandomParameters {
+const probejs$$marker: never
+}
+export class $SecureRandomParameters$$Static implements $SecureRandomParameters {
+
+
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $SecureRandomParameters$$Type = ($SecureRandomParameters);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $SecureRandomParameters_ = $SecureRandomParameters$$Type;
+}}
+declare module "java.security.CodeSigner" {
+import {$Timestamp, $Timestamp$$Type} from "java.security.Timestamp"
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$CertPath, $CertPath$$Type} from "java.security.cert.CertPath"
+
+export class $CodeSigner implements $Serializable {
+
+constructor(arg0: $CertPath$$Type, arg1: $Timestamp$$Type)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getSignerCertPath"(): $CertPath
+public "getTimestamp"(): $Timestamp
+get "signerCertPath"(): $CertPath
+get "timestamp"(): $Timestamp
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $CodeSigner$$Type = ($CodeSigner);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $CodeSigner_ = $CodeSigner$$Type;
+}}
+declare module "java.security.PrivilegedExceptionAction" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $PrivilegedExceptionAction<T> {
+
+ "run"(): T
+
+(): T
+}
+
+export namespace $PrivilegedExceptionAction {
+const probejs$$marker: never
+}
+export class $PrivilegedExceptionAction$$Static<T> implements $PrivilegedExceptionAction {
+
+
+ "run"(): T
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $PrivilegedExceptionAction$$Type<T> = (() => T);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $PrivilegedExceptionAction_<T> = $PrivilegedExceptionAction$$Type<(T)>;
+}}
+declare module "java.security.AccessControlContext" {
+import {$Permission, $Permission$$Type} from "java.security.Permission"
+import {$ProtectionDomain, $ProtectionDomain$$Type} from "java.security.ProtectionDomain"
+import {$DomainCombiner, $DomainCombiner$$Type} from "java.security.DomainCombiner"
+
+/**
+ * 
+ * @deprecated
+ */
+export class $AccessControlContext {
+
+constructor(arg0: $AccessControlContext$$Type, arg1: $DomainCombiner$$Type)
+constructor(arg0: ($ProtectionDomain$$Type)[])
+
+public "equals"(arg0: any): boolean
+public "hashCode"(): integer
+public "checkPermission"(arg0: $Permission$$Type): void
+public "getDomainCombiner"(): $DomainCombiner
+get "domainCombiner"(): $DomainCombiner
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $AccessControlContext$$Type = ($AccessControlContext);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $AccessControlContext_ = $AccessControlContext$$Type;
+}}

.probe/startup/probe-types/packages/java.text.d.ts

@@ -0,0 +1,797 @@
+declare module "java.text.NumberFormat" {
+import {$ParsePosition, $ParsePosition$$Type} from "java.text.ParsePosition"
+import {$FieldPosition, $FieldPosition$$Type} from "java.text.FieldPosition"
+import {$StringBuffer, $StringBuffer$$Type} from "java.lang.StringBuffer"
+import {$NumberFormat$Style, $NumberFormat$Style$$Type} from "java.text.NumberFormat$Style"
+import {$Locale, $Locale$$Type} from "java.util.Locale"
+import {$Format, $Format$$Type} from "java.text.Format"
+import {$Currency, $Currency$$Type} from "java.util.Currency"
+import {$RoundingMode, $RoundingMode$$Type} from "java.math.RoundingMode"
+
+export class $NumberFormat extends $Format {
+static readonly "FRACTION_FIELD": integer
+static readonly "INTEGER_FIELD": integer
+
+
+public "equals"(arg0: any): boolean
+public "hashCode"(): integer
+public "clone"(): any
+public "format"(arg0: long, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "format"(arg0: double, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "format"(arg0: any, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "format"(arg0: double): string
+public "format"(arg0: long): string
+public static "getInstance"(): $NumberFormat
+public static "getInstance"(arg0: $Locale$$Type): $NumberFormat
+public "parse"(arg0: string, arg1: $ParsePosition$$Type): number
+public "parse"(arg0: string): number
+public static "getAvailableLocales"(): ($Locale)[]
+public "parseObject"(arg0: string, arg1: $ParsePosition$$Type): any
+public "getMaximumIntegerDigits"(): integer
+public "getMinimumIntegerDigits"(): integer
+public "getMaximumFractionDigits"(): integer
+public "getMinimumFractionDigits"(): integer
+public "isGroupingUsed"(): boolean
+public "isParseIntegerOnly"(): boolean
+public "setGroupingUsed"(arg0: boolean): void
+public "setMinimumIntegerDigits"(arg0: integer): void
+public "setMaximumIntegerDigits"(arg0: integer): void
+public "setMaximumFractionDigits"(arg0: integer): void
+public "setMinimumFractionDigits"(arg0: integer): void
+public "getCurrency"(): $Currency
+public "setCurrency"(arg0: $Currency$$Type): void
+public "setRoundingMode"(arg0: $RoundingMode$$Type): void
+public "getRoundingMode"(): $RoundingMode
+public static "getNumberInstance"(): $NumberFormat
+public static "getNumberInstance"(arg0: $Locale$$Type): $NumberFormat
+public static "getPercentInstance"(): $NumberFormat
+public static "getPercentInstance"(arg0: $Locale$$Type): $NumberFormat
+public static "getCurrencyInstance"(arg0: $Locale$$Type): $NumberFormat
+public static "getCurrencyInstance"(): $NumberFormat
+public static "getIntegerInstance"(arg0: $Locale$$Type): $NumberFormat
+public static "getIntegerInstance"(): $NumberFormat
+public static "getCompactNumberInstance"(): $NumberFormat
+public static "getCompactNumberInstance"(arg0: $Locale$$Type, arg1: $NumberFormat$Style$$Type): $NumberFormat
+public "setParseIntegerOnly"(arg0: boolean): void
+get "maximumIntegerDigits"(): integer
+get "minimumIntegerDigits"(): integer
+get "maximumFractionDigits"(): integer
+get "minimumFractionDigits"(): integer
+get "groupingUsed"(): boolean
+get "parseIntegerOnly"(): boolean
+set "groupingUsed"(value: boolean)
+set "minimumIntegerDigits"(value: integer)
+set "maximumIntegerDigits"(value: integer)
+set "maximumFractionDigits"(value: integer)
+set "minimumFractionDigits"(value: integer)
+get "currency"(): $Currency
+set "currency"(value: $Currency$$Type)
+set "roundingMode"(value: $RoundingMode$$Type)
+get "roundingMode"(): $RoundingMode
+set "parseIntegerOnly"(value: boolean)
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $NumberFormat$$Type = ($NumberFormat);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $NumberFormat_ = $NumberFormat$$Type;
+}}
+declare module "java.text.DecimalFormatSymbols" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$Cloneable, $Cloneable$$Type} from "java.lang.Cloneable"
+import {$Locale, $Locale$$Type} from "java.util.Locale"
+import {$Currency, $Currency$$Type} from "java.util.Currency"
+
+export class $DecimalFormatSymbols implements $Cloneable, $Serializable {
+
+constructor()
+constructor(arg0: $Locale$$Type)
+
+public "equals"(arg0: any): boolean
+public "hashCode"(): integer
+public "clone"(): any
+public static "getInstance"(arg0: $Locale$$Type): $DecimalFormatSymbols
+public static "getInstance"(): $DecimalFormatSymbols
+public static "getAvailableLocales"(): ($Locale)[]
+public "getNaN"(): string
+public "getInfinity"(): string
+public "getZeroDigit"(): character
+public "getMonetaryGroupingSeparator"(): character
+public "getGroupingSeparator"(): character
+public "getMonetaryDecimalSeparator"(): character
+public "getDecimalSeparator"(): character
+public "getExponentSeparator"(): string
+public "getInternationalCurrencySymbol"(): string
+public "getCurrencySymbol"(): string
+public "getDigit"(): character
+public "getPatternSeparator"(): character
+public "getPercent"(): character
+public "getPerMill"(): character
+public "getMinusSign"(): character
+public "getCurrency"(): $Currency
+public "setCurrency"(arg0: $Currency$$Type): void
+public "getLocale"(): $Locale
+public "setZeroDigit"(arg0: character): void
+public "setGroupingSeparator"(arg0: character): void
+public "setDecimalSeparator"(arg0: character): void
+public "setPerMill"(arg0: character): void
+public "setPercent"(arg0: character): void
+public "setDigit"(arg0: character): void
+public "setPatternSeparator"(arg0: character): void
+public "setInfinity"(arg0: string): void
+public "setNaN"(arg0: string): void
+public "setMinusSign"(arg0: character): void
+public "setCurrencySymbol"(arg0: string): void
+public "setInternationalCurrencySymbol"(arg0: string): void
+public "setMonetaryDecimalSeparator"(arg0: character): void
+public "setExponentSeparator"(arg0: string): void
+public "setMonetaryGroupingSeparator"(arg0: character): void
+get "naN"(): string
+get "infinity"(): string
+get "zeroDigit"(): character
+get "monetaryGroupingSeparator"(): character
+get "groupingSeparator"(): character
+get "monetaryDecimalSeparator"(): character
+get "decimalSeparator"(): character
+get "exponentSeparator"(): string
+get "internationalCurrencySymbol"(): string
+get "currencySymbol"(): string
+get "digit"(): character
+get "patternSeparator"(): character
+get "percent"(): character
+get "perMill"(): character
+get "minusSign"(): character
+get "currency"(): $Currency
+set "currency"(value: $Currency$$Type)
+get "locale"(): $Locale
+set "zeroDigit"(value: character)
+set "groupingSeparator"(value: character)
+set "decimalSeparator"(value: character)
+set "perMill"(value: character)
+set "percent"(value: character)
+set "digit"(value: character)
+set "patternSeparator"(value: character)
+set "infinity"(value: string)
+set "naN"(value: string)
+set "minusSign"(value: character)
+set "currencySymbol"(value: string)
+set "internationalCurrencySymbol"(value: string)
+set "monetaryDecimalSeparator"(value: character)
+set "exponentSeparator"(value: string)
+set "monetaryGroupingSeparator"(value: character)
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $DecimalFormatSymbols$$Type = ($DecimalFormatSymbols);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $DecimalFormatSymbols_ = $DecimalFormatSymbols$$Type;
+}}
+declare module "java.text.DateFormatSymbols" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$Cloneable, $Cloneable$$Type} from "java.lang.Cloneable"
+import {$Locale, $Locale$$Type} from "java.util.Locale"
+
+export class $DateFormatSymbols implements $Serializable, $Cloneable {
+
+constructor(arg0: $Locale$$Type)
+constructor()
+
+public "equals"(arg0: any): boolean
+public "hashCode"(): integer
+public "clone"(): any
+public static "getInstance"(): $DateFormatSymbols
+public static "getInstance"(arg0: $Locale$$Type): $DateFormatSymbols
+public static "getAvailableLocales"(): ($Locale)[]
+public "getZoneStrings"(): ((string)[])[]
+public "getEras"(): (string)[]
+public "setEras"(arg0: (string)[]): void
+public "getMonths"(): (string)[]
+public "setMonths"(arg0: (string)[]): void
+public "getShortMonths"(): (string)[]
+public "setShortMonths"(arg0: (string)[]): void
+public "getWeekdays"(): (string)[]
+public "setWeekdays"(arg0: (string)[]): void
+public "getShortWeekdays"(): (string)[]
+public "setShortWeekdays"(arg0: (string)[]): void
+public "getAmPmStrings"(): (string)[]
+public "setAmPmStrings"(arg0: (string)[]): void
+public "setZoneStrings"(arg0: ((string)[])[]): void
+public "getLocalPatternChars"(): string
+public "setLocalPatternChars"(arg0: string): void
+get "zoneStrings"(): ((string)[])[]
+get "eras"(): (string)[]
+set "eras"(value: (string)[])
+get "months"(): (string)[]
+set "months"(value: (string)[])
+get "shortMonths"(): (string)[]
+set "shortMonths"(value: (string)[])
+get "weekdays"(): (string)[]
+set "weekdays"(value: (string)[])
+get "shortWeekdays"(): (string)[]
+set "shortWeekdays"(value: (string)[])
+get "amPmStrings"(): (string)[]
+set "amPmStrings"(value: (string)[])
+set "zoneStrings"(value: ((string)[])[])
+get "localPatternChars"(): string
+set "localPatternChars"(value: string)
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $DateFormatSymbols$$Type = ($DateFormatSymbols);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $DateFormatSymbols_ = $DateFormatSymbols$$Type;
+}}
+declare module "java.text.CharacterIterator" {
+import {$Cloneable, $Cloneable$$Type} from "java.lang.Cloneable"
+
+export interface $CharacterIterator extends $Cloneable {
+
+ "clone"(): any
+ "next"(): character
+ "last"(): character
+ "first"(): character
+ "current"(): character
+ "previous"(): character
+ "getIndex"(): integer
+ "getBeginIndex"(): integer
+ "getEndIndex"(): integer
+ "setIndex"(arg0: integer): character
+get "index"(): integer
+get "beginIndex"(): integer
+get "endIndex"(): integer
+set "index"(value: integer)
+}
+
+export namespace $CharacterIterator {
+const DONE: character
+const probejs$$marker: never
+}
+export class $CharacterIterator$$Static implements $CharacterIterator {
+static readonly "DONE": character
+
+
+ "clone"(): any
+ "next"(): character
+ "last"(): character
+ "first"(): character
+ "current"(): character
+ "previous"(): character
+ "getIndex"(): integer
+ "getBeginIndex"(): integer
+ "getEndIndex"(): integer
+ "setIndex"(arg0: integer): character
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $CharacterIterator$$Type = ($CharacterIterator);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $CharacterIterator_ = $CharacterIterator$$Type;
+}}
+declare module "java.text.ParsePosition" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export class $ParsePosition {
+
+constructor(arg0: integer)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getIndex"(): integer
+public "getErrorIndex"(): integer
+public "setErrorIndex"(arg0: integer): void
+public "setIndex"(arg0: integer): void
+get "index"(): integer
+get "errorIndex"(): integer
+set "errorIndex"(value: integer)
+set "index"(value: integer)
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $ParsePosition$$Type = ($ParsePosition);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $ParsePosition_ = $ParsePosition$$Type;
+}}
+declare module "java.text.DateFormat" {
+import {$ParsePosition, $ParsePosition$$Type} from "java.text.ParsePosition"
+import {$FieldPosition, $FieldPosition$$Type} from "java.text.FieldPosition"
+import {$NumberFormat, $NumberFormat$$Type} from "java.text.NumberFormat"
+import {$StringBuffer, $StringBuffer$$Type} from "java.lang.StringBuffer"
+import {$TimeZone, $TimeZone$$Type} from "java.util.TimeZone"
+import {$Date, $Date$$Type} from "java.util.Date"
+import {$Locale, $Locale$$Type} from "java.util.Locale"
+import {$Format, $Format$$Type} from "java.text.Format"
+import {$Calendar, $Calendar$$Type} from "java.util.Calendar"
+
+export class $DateFormat extends $Format {
+static readonly "DAY_OF_YEAR_FIELD": integer
+static readonly "DATE_FIELD": integer
+static readonly "MILLISECOND_FIELD": integer
+static readonly "MEDIUM": integer
+static readonly "YEAR_FIELD": integer
+static readonly "DAY_OF_WEEK_IN_MONTH_FIELD": integer
+static readonly "MINUTE_FIELD": integer
+static readonly "FULL": integer
+static readonly "ERA_FIELD": integer
+static readonly "AM_PM_FIELD": integer
+static readonly "SHORT": integer
+static readonly "HOUR_OF_DAY1_FIELD": integer
+static readonly "MONTH_FIELD": integer
+static readonly "DAY_OF_WEEK_FIELD": integer
+static readonly "WEEK_OF_YEAR_FIELD": integer
+static readonly "HOUR1_FIELD": integer
+static readonly "HOUR_OF_DAY0_FIELD": integer
+static readonly "WEEK_OF_MONTH_FIELD": integer
+static readonly "TIMEZONE_FIELD": integer
+static readonly "HOUR0_FIELD": integer
+static readonly "DEFAULT": integer
+static readonly "SECOND_FIELD": integer
+static readonly "LONG": integer
+
+
+public "equals"(arg0: any): boolean
+public "hashCode"(): integer
+public "clone"(): any
+public "format"(arg0: any, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "format"(arg0: $Date$$Type): string
+public "format"(arg0: $Date$$Type, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public static "getInstance"(): $DateFormat
+public "parse"(arg0: string): $Date
+public "parse"(arg0: string, arg1: $ParsePosition$$Type): $Date
+public static "getDateTimeInstance"(arg0: integer, arg1: integer): $DateFormat
+public static "getDateTimeInstance"(arg0: integer, arg1: integer, arg2: $Locale$$Type): $DateFormat
+public static "getDateTimeInstance"(): $DateFormat
+public static "getAvailableLocales"(): ($Locale)[]
+public "setTimeZone"(arg0: $TimeZone$$Type): void
+public "getTimeZone"(): $TimeZone
+public "setLenient"(arg0: boolean): void
+public "isLenient"(): boolean
+public static "getDateInstance"(arg0: integer): $DateFormat
+public static "getDateInstance"(arg0: integer, arg1: $Locale$$Type): $DateFormat
+public static "getDateInstance"(): $DateFormat
+public static "getTimeInstance"(arg0: integer, arg1: $Locale$$Type): $DateFormat
+public static "getTimeInstance"(arg0: integer): $DateFormat
+public static "getTimeInstance"(): $DateFormat
+public "parseObject"(arg0: string, arg1: $ParsePosition$$Type): any
+public "setCalendar"(arg0: $Calendar$$Type): void
+public "getCalendar"(): $Calendar
+public "setNumberFormat"(arg0: $NumberFormat$$Type): void
+public "getNumberFormat"(): $NumberFormat
+set "timeZone"(value: $TimeZone$$Type)
+get "timeZone"(): $TimeZone
+set "lenient"(value: boolean)
+get "lenient"(): boolean
+set "calendar"(value: $Calendar$$Type)
+get "calendar"(): $Calendar
+set "numberFormat"(value: $NumberFormat$$Type)
+get "numberFormat"(): $NumberFormat
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $DateFormat$$Type = ($DateFormat);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $DateFormat_ = $DateFormat$$Type;
+}}
+declare module "java.text.DecimalFormat" {
+import {$AttributedCharacterIterator, $AttributedCharacterIterator$$Type} from "java.text.AttributedCharacterIterator"
+import {$FieldPosition, $FieldPosition$$Type} from "java.text.FieldPosition"
+import {$NumberFormat, $NumberFormat$$Type} from "java.text.NumberFormat"
+import {$StringBuffer, $StringBuffer$$Type} from "java.lang.StringBuffer"
+import {$ParsePosition, $ParsePosition$$Type} from "java.text.ParsePosition"
+import {$Currency, $Currency$$Type} from "java.util.Currency"
+import {$DecimalFormatSymbols, $DecimalFormatSymbols$$Type} from "java.text.DecimalFormatSymbols"
+import {$RoundingMode, $RoundingMode$$Type} from "java.math.RoundingMode"
+
+export class $DecimalFormat extends $NumberFormat {
+static readonly "FRACTION_FIELD": integer
+static readonly "INTEGER_FIELD": integer
+
+constructor(arg0: string, arg1: $DecimalFormatSymbols$$Type)
+constructor(arg0: string)
+constructor()
+
+public "equals"(arg0: any): boolean
+public "hashCode"(): integer
+public "clone"(): any
+public "format"(arg0: double, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "format"(arg0: any, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "format"(arg0: long, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "parse"(arg0: string, arg1: $ParsePosition$$Type): number
+public "formatToCharacterIterator"(arg0: any): $AttributedCharacterIterator
+public "getMaximumIntegerDigits"(): integer
+public "getMinimumIntegerDigits"(): integer
+public "getMaximumFractionDigits"(): integer
+public "getMinimumFractionDigits"(): integer
+public "applyPattern"(arg0: string): void
+public "isParseBigDecimal"(): boolean
+public "setGroupingUsed"(arg0: boolean): void
+public "toPattern"(): string
+public "setMinimumIntegerDigits"(arg0: integer): void
+public "setMaximumIntegerDigits"(arg0: integer): void
+public "setMaximumFractionDigits"(arg0: integer): void
+public "setMinimumFractionDigits"(arg0: integer): void
+public "setDecimalSeparatorAlwaysShown"(arg0: boolean): void
+public "getCurrency"(): $Currency
+public "setCurrency"(arg0: $Currency$$Type): void
+public "setRoundingMode"(arg0: $RoundingMode$$Type): void
+public "getRoundingMode"(): $RoundingMode
+public "getDecimalFormatSymbols"(): $DecimalFormatSymbols
+public "setDecimalFormatSymbols"(arg0: $DecimalFormatSymbols$$Type): void
+public "getPositivePrefix"(): string
+public "setPositivePrefix"(arg0: string): void
+public "getNegativePrefix"(): string
+public "setNegativePrefix"(arg0: string): void
+public "getPositiveSuffix"(): string
+public "setPositiveSuffix"(arg0: string): void
+public "getNegativeSuffix"(): string
+public "setNegativeSuffix"(arg0: string): void
+public "getMultiplier"(): integer
+public "setMultiplier"(arg0: integer): void
+public "getGroupingSize"(): integer
+public "setGroupingSize"(arg0: integer): void
+public "isDecimalSeparatorAlwaysShown"(): boolean
+public "setParseBigDecimal"(arg0: boolean): void
+public "toLocalizedPattern"(): string
+public "applyLocalizedPattern"(arg0: string): void
+get "maximumIntegerDigits"(): integer
+get "minimumIntegerDigits"(): integer
+get "maximumFractionDigits"(): integer
+get "minimumFractionDigits"(): integer
+get "parseBigDecimal"(): boolean
+set "groupingUsed"(value: boolean)
+set "minimumIntegerDigits"(value: integer)
+set "maximumIntegerDigits"(value: integer)
+set "maximumFractionDigits"(value: integer)
+set "minimumFractionDigits"(value: integer)
+set "decimalSeparatorAlwaysShown"(value: boolean)
+get "currency"(): $Currency
+set "currency"(value: $Currency$$Type)
+set "roundingMode"(value: $RoundingMode$$Type)
+get "roundingMode"(): $RoundingMode
+get "decimalFormatSymbols"(): $DecimalFormatSymbols
+set "decimalFormatSymbols"(value: $DecimalFormatSymbols$$Type)
+get "positivePrefix"(): string
+set "positivePrefix"(value: string)
+get "negativePrefix"(): string
+set "negativePrefix"(value: string)
+get "positiveSuffix"(): string
+set "positiveSuffix"(value: string)
+get "negativeSuffix"(): string
+set "negativeSuffix"(value: string)
+get "multiplier"(): integer
+set "multiplier"(value: integer)
+get "groupingSize"(): integer
+set "groupingSize"(value: integer)
+get "decimalSeparatorAlwaysShown"(): boolean
+set "parseBigDecimal"(value: boolean)
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $DecimalFormat$$Type = ($DecimalFormat);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $DecimalFormat_ = $DecimalFormat$$Type;
+}}
+declare module "java.text.SimpleDateFormat" {
+import {$AttributedCharacterIterator, $AttributedCharacterIterator$$Type} from "java.text.AttributedCharacterIterator"
+import {$DateFormatSymbols, $DateFormatSymbols$$Type} from "java.text.DateFormatSymbols"
+import {$FieldPosition, $FieldPosition$$Type} from "java.text.FieldPosition"
+import {$StringBuffer, $StringBuffer$$Type} from "java.lang.StringBuffer"
+import {$ParsePosition, $ParsePosition$$Type} from "java.text.ParsePosition"
+import {$Date, $Date$$Type} from "java.util.Date"
+import {$Locale, $Locale$$Type} from "java.util.Locale"
+import {$DateFormat, $DateFormat$$Type} from "java.text.DateFormat"
+
+export class $SimpleDateFormat extends $DateFormat {
+static readonly "DAY_OF_YEAR_FIELD": integer
+static readonly "DATE_FIELD": integer
+static readonly "MILLISECOND_FIELD": integer
+static readonly "MEDIUM": integer
+static readonly "YEAR_FIELD": integer
+static readonly "DAY_OF_WEEK_IN_MONTH_FIELD": integer
+static readonly "MINUTE_FIELD": integer
+static readonly "FULL": integer
+static readonly "ERA_FIELD": integer
+static readonly "AM_PM_FIELD": integer
+static readonly "SHORT": integer
+static readonly "HOUR_OF_DAY1_FIELD": integer
+static readonly "MONTH_FIELD": integer
+static readonly "DAY_OF_WEEK_FIELD": integer
+static readonly "WEEK_OF_YEAR_FIELD": integer
+static readonly "HOUR1_FIELD": integer
+static readonly "HOUR_OF_DAY0_FIELD": integer
+static readonly "WEEK_OF_MONTH_FIELD": integer
+static readonly "TIMEZONE_FIELD": integer
+static readonly "HOUR0_FIELD": integer
+static readonly "DEFAULT": integer
+static readonly "SECOND_FIELD": integer
+static readonly "LONG": integer
+
+constructor(arg0: string, arg1: $DateFormatSymbols$$Type)
+constructor(arg0: string, arg1: $Locale$$Type)
+constructor(arg0: string)
+constructor()
+
+public "equals"(arg0: any): boolean
+public "hashCode"(): integer
+public "clone"(): any
+public "format"(arg0: $Date$$Type, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "parse"(arg0: string, arg1: $ParsePosition$$Type): $Date
+public "formatToCharacterIterator"(arg0: any): $AttributedCharacterIterator
+public "applyPattern"(arg0: string): void
+public "toPattern"(): string
+public "toLocalizedPattern"(): string
+public "applyLocalizedPattern"(arg0: string): void
+public "set2DigitYearStart"(arg0: $Date$$Type): void
+public "get2DigitYearStart"(): $Date
+public "getDateFormatSymbols"(): $DateFormatSymbols
+public "setDateFormatSymbols"(arg0: $DateFormatSymbols$$Type): void
+set "2DigitYearStart"(value: $Date$$Type)
+get "2DigitYearStart"(): $Date
+get "dateFormatSymbols"(): $DateFormatSymbols
+set "dateFormatSymbols"(value: $DateFormatSymbols$$Type)
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $SimpleDateFormat$$Type = ($SimpleDateFormat);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $SimpleDateFormat_ = $SimpleDateFormat$$Type;
+}}
+declare module "java.text.Format$Field" {
+import {$AttributedCharacterIterator$Attribute, $AttributedCharacterIterator$Attribute$$Type} from "java.text.AttributedCharacterIterator$Attribute"
+
+export class $Format$Field extends $AttributedCharacterIterator$Attribute {
+static readonly "LANGUAGE": $AttributedCharacterIterator$Attribute
+static readonly "INPUT_METHOD_SEGMENT": $AttributedCharacterIterator$Attribute
+static readonly "READING": $AttributedCharacterIterator$Attribute
+
+
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Format$Field$$Type = ($Format$Field);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Format$Field_ = $Format$Field$$Type;
+}}
+declare module "java.text.NumberFormat$Style" {
+import {$Enum, $Enum$$Type} from "java.lang.Enum"
+
+export class $NumberFormat$Style extends $Enum<($NumberFormat$Style)> {
+static readonly "SHORT": $NumberFormat$Style
+static readonly "LONG": $NumberFormat$Style
+
+
+public static "values"(): ($NumberFormat$Style)[]
+public static "valueOf"(arg0: string): $NumberFormat$Style
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $NumberFormat$Style$$Type = (("short") | ("long"));
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $NumberFormat$Style_ = $NumberFormat$Style$$Type;
+}}
+declare module "java.text.FieldPosition" {
+import {$Format$Field, $Format$Field$$Type} from "java.text.Format$Field"
+
+export class $FieldPosition {
+
+constructor(arg0: $Format$Field$$Type, arg1: integer)
+constructor(arg0: $Format$Field$$Type)
+constructor(arg0: integer)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getField"(): integer
+public "setBeginIndex"(arg0: integer): void
+public "setEndIndex"(arg0: integer): void
+public "getFieldAttribute"(): $Format$Field
+public "getBeginIndex"(): integer
+public "getEndIndex"(): integer
+get "field"(): integer
+set "beginIndex"(value: integer)
+set "endIndex"(value: integer)
+get "fieldAttribute"(): $Format$Field
+get "beginIndex"(): integer
+get "endIndex"(): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $FieldPosition$$Type = ($FieldPosition);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $FieldPosition_ = $FieldPosition$$Type;
+}}
+declare module "java.text.Format" {
+import {$AttributedCharacterIterator, $AttributedCharacterIterator$$Type} from "java.text.AttributedCharacterIterator"
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$FieldPosition, $FieldPosition$$Type} from "java.text.FieldPosition"
+import {$StringBuffer, $StringBuffer$$Type} from "java.lang.StringBuffer"
+import {$ParsePosition, $ParsePosition$$Type} from "java.text.ParsePosition"
+import {$Cloneable, $Cloneable$$Type} from "java.lang.Cloneable"
+
+export class $Format implements $Serializable, $Cloneable {
+
+
+public "clone"(): any
+public "format"(arg0: any, arg1: $StringBuffer$$Type, arg2: $FieldPosition$$Type): $StringBuffer
+public "format"(arg0: any): string
+public "parseObject"(arg0: string): any
+public "parseObject"(arg0: string, arg1: $ParsePosition$$Type): any
+public "formatToCharacterIterator"(arg0: any): $AttributedCharacterIterator
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Format$$Type = ($Format);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Format_ = $Format$$Type;
+}}
+declare module "java.text.AttributedCharacterIterator$Attribute" {
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+
+export class $AttributedCharacterIterator$Attribute implements $Serializable {
+static readonly "LANGUAGE": $AttributedCharacterIterator$Attribute
+static readonly "INPUT_METHOD_SEGMENT": $AttributedCharacterIterator$Attribute
+static readonly "READING": $AttributedCharacterIterator$Attribute
+
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $AttributedCharacterIterator$Attribute$$Type = ($AttributedCharacterIterator$Attribute);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $AttributedCharacterIterator$Attribute_ = $AttributedCharacterIterator$Attribute$$Type;
+}}
+declare module "java.text.AttributedCharacterIterator" {
+import {$Map, $Map$$Type} from "java.util.Map"
+import {$CharacterIterator, $CharacterIterator$$Type} from "java.text.CharacterIterator"
+import {$Set, $Set$$Type} from "java.util.Set"
+import {$AttributedCharacterIterator$Attribute, $AttributedCharacterIterator$Attribute$$Type} from "java.text.AttributedCharacterIterator$Attribute"
+
+export interface $AttributedCharacterIterator extends $CharacterIterator {
+
+ "getAttributes"(): $Map<($AttributedCharacterIterator$Attribute), (any)>
+ "getAttribute"(arg0: $AttributedCharacterIterator$Attribute$$Type): any
+ "getRunLimit"(): integer
+ "getRunLimit"(arg0: $Set$$Type<($AttributedCharacterIterator$Attribute$$Type)>): integer
+ "getRunLimit"(arg0: $AttributedCharacterIterator$Attribute$$Type): integer
+ "getRunStart"(arg0: $AttributedCharacterIterator$Attribute$$Type): integer
+ "getRunStart"(arg0: $Set$$Type<($AttributedCharacterIterator$Attribute$$Type)>): integer
+ "getRunStart"(): integer
+ "getAllAttributeKeys"(): $Set<($AttributedCharacterIterator$Attribute)>
+ "clone"(): any
+ "next"(): character
+ "last"(): character
+ "first"(): character
+ "current"(): character
+ "previous"(): character
+ "getIndex"(): integer
+ "getBeginIndex"(): integer
+ "getEndIndex"(): integer
+ "setIndex"(arg0: integer): character
+get "attributes"(): $Map<($AttributedCharacterIterator$Attribute), (any)>
+get "runLimit"(): integer
+get "runStart"(): integer
+get "allAttributeKeys"(): $Set<($AttributedCharacterIterator$Attribute)>
+get "index"(): integer
+get "beginIndex"(): integer
+get "endIndex"(): integer
+set "index"(value: integer)
+}
+
+export namespace $AttributedCharacterIterator {
+const probejs$$marker: never
+}
+export class $AttributedCharacterIterator$$Static implements $AttributedCharacterIterator {
+
+
+ "getAttributes"(): $Map<($AttributedCharacterIterator$Attribute), (any)>
+ "getAttribute"(arg0: $AttributedCharacterIterator$Attribute$$Type): any
+ "getRunLimit"(): integer
+ "getRunLimit"(arg0: $Set$$Type<($AttributedCharacterIterator$Attribute$$Type)>): integer
+ "getRunLimit"(arg0: $AttributedCharacterIterator$Attribute$$Type): integer
+ "getRunStart"(arg0: $AttributedCharacterIterator$Attribute$$Type): integer
+ "getRunStart"(arg0: $Set$$Type<($AttributedCharacterIterator$Attribute$$Type)>): integer
+ "getRunStart"(): integer
+ "getAllAttributeKeys"(): $Set<($AttributedCharacterIterator$Attribute)>
+ "clone"(): any
+ "next"(): character
+ "last"(): character
+ "first"(): character
+ "current"(): character
+ "previous"(): character
+ "getIndex"(): integer
+ "getBeginIndex"(): integer
+ "getEndIndex"(): integer
+ "setIndex"(arg0: integer): character
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $AttributedCharacterIterator$$Type = ($AttributedCharacterIterator);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $AttributedCharacterIterator_ = $AttributedCharacterIterator$$Type;
+}}

.probe/startup/probe-types/packages/javax.crypto.d.ts

@@ -0,0 +1,114 @@
+declare module "javax.crypto.Cipher" {
+import {$ExemptionMechanism, $ExemptionMechanism$$Type} from "javax.crypto.ExemptionMechanism"
+import {$Certificate, $Certificate$$Type} from "java.security.cert.Certificate"
+import {$Provider, $Provider$$Type} from "java.security.Provider"
+import {$AlgorithmParameters, $AlgorithmParameters$$Type} from "java.security.AlgorithmParameters"
+import {$SecureRandom, $SecureRandom$$Type} from "java.security.SecureRandom"
+import {$ByteBuffer, $ByteBuffer$$Type} from "java.nio.ByteBuffer"
+import {$Key, $Key$$Type} from "java.security.Key"
+import {$AlgorithmParameterSpec, $AlgorithmParameterSpec$$Type} from "java.security.spec.AlgorithmParameterSpec"
+
+export class $Cipher {
+static readonly "WRAP_MODE": integer
+static readonly "UNWRAP_MODE": integer
+static readonly "ENCRYPT_MODE": integer
+static readonly "PUBLIC_KEY": integer
+static readonly "PRIVATE_KEY": integer
+static readonly "SECRET_KEY": integer
+static readonly "DECRYPT_MODE": integer
+
+
+public "getBlockSize"(): integer
+public "toString"(): string
+public "update"(arg0: (byte)[], arg1: integer, arg2: integer, arg3: (byte)[]): integer
+public "update"(arg0: (byte)[], arg1: integer, arg2: integer, arg3: (byte)[], arg4: integer): integer
+public "update"(arg0: $ByteBuffer$$Type, arg1: $ByteBuffer$$Type): integer
+public "update"(arg0: (byte)[], arg1: integer, arg2: integer): (byte)[]
+public "update"(arg0: (byte)[]): (byte)[]
+public "wrap"(arg0: $Key$$Type): (byte)[]
+public static "getInstance"(arg0: string): $Cipher
+public static "getInstance"(arg0: string, arg1: string): $Cipher
+public static "getInstance"(arg0: string, arg1: $Provider$$Type): $Cipher
+public "init"(arg0: integer, arg1: $Key$$Type, arg2: $AlgorithmParameters$$Type): void
+public "init"(arg0: integer, arg1: $Key$$Type, arg2: $AlgorithmParameterSpec$$Type): void
+public "init"(arg0: integer, arg1: $Key$$Type, arg2: $SecureRandom$$Type): void
+public "init"(arg0: integer, arg1: $Key$$Type): void
+public "init"(arg0: integer, arg1: $Key$$Type, arg2: $AlgorithmParameterSpec$$Type, arg3: $SecureRandom$$Type): void
+public "init"(arg0: integer, arg1: $Certificate$$Type): void
+public "init"(arg0: integer, arg1: $Certificate$$Type, arg2: $SecureRandom$$Type): void
+public "init"(arg0: integer, arg1: $Key$$Type, arg2: $AlgorithmParameters$$Type, arg3: $SecureRandom$$Type): void
+public "getParameters"(): $AlgorithmParameters
+public "unwrap"(arg0: (byte)[], arg1: string, arg2: integer): $Key
+public "getProvider"(): $Provider
+public "getAlgorithm"(): string
+public static "getMaxAllowedKeyLength"(arg0: string): integer
+public "getExemptionMechanism"(): $ExemptionMechanism
+public "updateAAD"(arg0: (byte)[]): void
+public "updateAAD"(arg0: (byte)[], arg1: integer, arg2: integer): void
+public "updateAAD"(arg0: $ByteBuffer$$Type): void
+public "getOutputSize"(arg0: integer): integer
+public "getIV"(): (byte)[]
+public "doFinal"(): (byte)[]
+public "doFinal"(arg0: (byte)[], arg1: integer, arg2: integer, arg3: (byte)[], arg4: integer): integer
+public "doFinal"(arg0: (byte)[], arg1: integer, arg2: integer, arg3: (byte)[]): integer
+public "doFinal"(arg0: (byte)[], arg1: integer, arg2: integer): (byte)[]
+public "doFinal"(arg0: (byte)[]): (byte)[]
+public "doFinal"(arg0: $ByteBuffer$$Type, arg1: $ByteBuffer$$Type): integer
+public "doFinal"(arg0: (byte)[], arg1: integer): integer
+public static "getMaxAllowedParameterSpec"(arg0: string): $AlgorithmParameterSpec
+get "blockSize"(): integer
+get "parameters"(): $AlgorithmParameters
+get "provider"(): $Provider
+get "algorithm"(): string
+get "exemptionMechanism"(): $ExemptionMechanism
+get "iV"(): (byte)[]
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Cipher$$Type = ($Cipher);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Cipher_ = $Cipher$$Type;
+}}
+declare module "javax.crypto.ExemptionMechanism" {
+import {$Provider, $Provider$$Type} from "java.security.Provider"
+import {$AlgorithmParameters, $AlgorithmParameters$$Type} from "java.security.AlgorithmParameters"
+import {$Key, $Key$$Type} from "java.security.Key"
+import {$AlgorithmParameterSpec, $AlgorithmParameterSpec$$Type} from "java.security.spec.AlgorithmParameterSpec"
+
+export class $ExemptionMechanism {
+
+
+public "getName"(): string
+public static "getInstance"(arg0: string, arg1: string): $ExemptionMechanism
+public static "getInstance"(arg0: string, arg1: $Provider$$Type): $ExemptionMechanism
+public static "getInstance"(arg0: string): $ExemptionMechanism
+public "init"(arg0: $Key$$Type, arg1: $AlgorithmParameterSpec$$Type): void
+public "init"(arg0: $Key$$Type): void
+public "init"(arg0: $Key$$Type, arg1: $AlgorithmParameters$$Type): void
+public "getProvider"(): $Provider
+public "genExemptionBlob"(arg0: (byte)[]): integer
+public "genExemptionBlob"(): (byte)[]
+public "genExemptionBlob"(arg0: (byte)[], arg1: integer): integer
+public "isCryptoAllowed"(arg0: $Key$$Type): boolean
+public "getOutputSize"(arg0: integer): integer
+get "name"(): string
+get "provider"(): $Provider
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $ExemptionMechanism$$Type = ($ExemptionMechanism);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $ExemptionMechanism_ = $ExemptionMechanism$$Type;
+}}

.probe/startup/probe-types/packages/javax.security.d.ts

@@ -0,0 +1,100 @@
+declare module "javax.security.auth.Subject" {
+import {$PrivilegedAction, $PrivilegedAction$$Type} from "java.security.PrivilegedAction"
+import {$Principal, $Principal$$Type} from "java.security.Principal"
+import {$Callable, $Callable$$Type} from "java.util.concurrent.Callable"
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+import {$PrivilegedExceptionAction, $PrivilegedExceptionAction$$Type} from "java.security.PrivilegedExceptionAction"
+import {$AccessControlContext, $AccessControlContext$$Type} from "java.security.AccessControlContext"
+import {$Set, $Set$$Type} from "java.util.Set"
+import {$Class, $Class$$Type} from "java.lang.Class"
+
+export class $Subject implements $Serializable {
+
+constructor()
+constructor(arg0: boolean, arg1: $Set$$Type<($Principal$$Type)>, arg2: $Set$$Type<(any)>, arg3: $Set$$Type<(any)>)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "setReadOnly"(): void
+public "getPrincipals"(): $Set<($Principal)>
+public "getPrincipals"<T extends $Principal>(arg0: $Class$$Type<(T)>): $Set<(T)>
+public static "current"(): $Subject
+public "isReadOnly"(): boolean
+/**
+ * 
+ * @deprecated
+ */
+public static "getSubject"(arg0: $AccessControlContext$$Type): $Subject
+/**
+ * 
+ * @deprecated
+ */
+public static "doAs"<T>(arg0: $Subject$$Type, arg1: $PrivilegedAction$$Type<(T)>): T
+/**
+ * 
+ * @deprecated
+ */
+public static "doAs"<T>(arg0: $Subject$$Type, arg1: $PrivilegedExceptionAction$$Type<(T)>): T
+public static "callAs"<T>(arg0: $Subject$$Type, arg1: $Callable$$Type<(T)>): T
+/**
+ * 
+ * @deprecated
+ */
+public static "doAsPrivileged"<T>(arg0: $Subject$$Type, arg1: $PrivilegedAction$$Type<(T)>, arg2: $AccessControlContext$$Type): T
+/**
+ * 
+ * @deprecated
+ */
+public static "doAsPrivileged"<T>(arg0: $Subject$$Type, arg1: $PrivilegedExceptionAction$$Type<(T)>, arg2: $AccessControlContext$$Type): T
+public "getPublicCredentials"(): $Set<(any)>
+public "getPublicCredentials"<T>(arg0: $Class$$Type<(T)>): $Set<(T)>
+public "getPrivateCredentials"(): $Set<(any)>
+public "getPrivateCredentials"<T>(arg0: $Class$$Type<(T)>): $Set<(T)>
+get "principals"(): $Set<($Principal)>
+get "readOnly"(): boolean
+get "publicCredentials"(): $Set<(any)>
+get "privateCredentials"(): $Set<(any)>
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Subject$$Type = ($Subject);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Subject_ = $Subject$$Type;
+}}
+declare module "javax.security.auth.Destroyable" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $Destroyable {
+
+ "isDestroyed"(): boolean
+ "destroy"(): void
+get "destroyed"(): boolean
+}
+
+export namespace $Destroyable {
+const probejs$$marker: never
+}
+export class $Destroyable$$Static implements $Destroyable {
+
+
+ "isDestroyed"(): boolean
+ "destroy"(): void
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Destroyable$$Type = ($Destroyable);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Destroyable_ = $Destroyable$$Type;
+}}

.probe/startup/probe-types/packages/javax.sound.d.ts

@@ -0,0 +1,68 @@
+declare module "javax.sound.sampled.AudioFormat$Encoding" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export class $AudioFormat$Encoding {
+static readonly "PCM_UNSIGNED": $AudioFormat$Encoding
+static readonly "ULAW": $AudioFormat$Encoding
+static readonly "PCM_FLOAT": $AudioFormat$Encoding
+static readonly "PCM_SIGNED": $AudioFormat$Encoding
+static readonly "ALAW": $AudioFormat$Encoding
+
+constructor(arg0: string)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $AudioFormat$Encoding$$Type = ($AudioFormat$Encoding);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $AudioFormat$Encoding_ = $AudioFormat$Encoding$$Type;
+}}
+declare module "javax.sound.sampled.AudioFormat" {
+import {$Map, $Map$$Type} from "java.util.Map"
+import {$AudioFormat$Encoding, $AudioFormat$Encoding$$Type} from "javax.sound.sampled.AudioFormat$Encoding"
+
+export class $AudioFormat {
+
+constructor(arg0: float, arg1: integer, arg2: integer, arg3: boolean, arg4: boolean)
+constructor(arg0: $AudioFormat$Encoding$$Type, arg1: float, arg2: integer, arg3: integer, arg4: integer, arg5: float, arg6: boolean, arg7: $Map$$Type<(string), (any)>)
+constructor(arg0: $AudioFormat$Encoding$$Type, arg1: float, arg2: integer, arg3: integer, arg4: integer, arg5: float, arg6: boolean)
+
+public "getProperty"(arg0: string): any
+public "toString"(): string
+public "matches"(arg0: $AudioFormat$$Type): boolean
+public "properties"(): $Map<(string), (any)>
+public "isBigEndian"(): boolean
+public "getEncoding"(): $AudioFormat$Encoding
+public "getSampleRate"(): float
+public "getChannels"(): integer
+public "getSampleSizeInBits"(): integer
+public "getFrameRate"(): float
+public "getFrameSize"(): integer
+get "bigEndian"(): boolean
+get "encoding"(): $AudioFormat$Encoding
+get "sampleRate"(): float
+get "channels"(): integer
+get "sampleSizeInBits"(): integer
+get "frameRate"(): float
+get "frameSize"(): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $AudioFormat$$Type = ($AudioFormat);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $AudioFormat_ = $AudioFormat$$Type;
+}}

.probe/startup/probe-types/packages/org.apache.d.ts

@@ -0,0 +1,745 @@
+declare module "org.apache.maven.artifact.repository.ArtifactRepository" {
+import {$ArtifactRepositoryPolicy, $ArtifactRepositoryPolicy$$Type} from "org.apache.maven.artifact.repository.ArtifactRepositoryPolicy"
+import {$List, $List$$Type} from "java.util.List"
+import {$Artifact, $Artifact$$Type} from "org.apache.maven.artifact.Artifact"
+import {$Proxy, $Proxy$$Type} from "org.apache.maven.repository.Proxy"
+import {$ArtifactMetadata, $ArtifactMetadata$$Type} from "org.apache.maven.artifact.metadata.ArtifactMetadata"
+import {$ArtifactRepositoryLayout, $ArtifactRepositoryLayout$$Type} from "org.apache.maven.artifact.repository.layout.ArtifactRepositoryLayout"
+import {$Authentication, $Authentication$$Type} from "org.apache.maven.artifact.repository.Authentication"
+
+export interface $ArtifactRepository {
+
+ "getKey"(): string
+ "find"(arg0: $Artifact$$Type): $Artifact
+ "getId"(): string
+ "getProtocol"(): string
+/**
+ * 
+ * @deprecated
+ */
+ "isUniqueVersion"(): boolean
+/**
+ * 
+ * @deprecated
+ */
+ "isBlacklisted"(): boolean
+/**
+ * 
+ * @deprecated
+ */
+ "setBlacklisted"(arg0: boolean): void
+ "isProjectAware"(): boolean
+ "setAuthentication"(arg0: $Authentication$$Type): void
+ "getAuthentication"(): $Authentication
+ "findVersions"(arg0: $Artifact$$Type): $List<(string)>
+ "pathOfLocalRepositoryMetadata"(arg0: $ArtifactMetadata$$Type, arg1: $ArtifactRepository$$Type): string
+ "pathOfRemoteRepositoryMetadata"(arg0: $ArtifactMetadata$$Type): string
+ "setLayout"(arg0: $ArtifactRepositoryLayout$$Type): void
+ "setId"(arg0: string): void
+ "getUrl"(): string
+ "getLayout"(): $ArtifactRepositoryLayout
+ "getReleases"(): $ArtifactRepositoryPolicy
+ "getSnapshots"(): $ArtifactRepositoryPolicy
+ "setBlocked"(arg0: boolean): void
+ "pathOf"(arg0: $Artifact$$Type): string
+ "isBlocked"(): boolean
+ "getProxy"(): $Proxy
+ "setProxy"(arg0: $Proxy$$Type): void
+ "getBasedir"(): string
+ "setUrl"(arg0: string): void
+ "setMirroredRepositories"(arg0: $List$$Type<($ArtifactRepository$$Type)>): void
+ "setReleaseUpdatePolicy"(arg0: $ArtifactRepositoryPolicy$$Type): void
+ "getMirroredRepositories"(): $List<($ArtifactRepository)>
+ "setSnapshotUpdatePolicy"(arg0: $ArtifactRepositoryPolicy$$Type): void
+get "key"(): string
+get "id"(): string
+get "protocol"(): string
+get "uniqueVersion"(): boolean
+get "blacklisted"(): boolean
+set "blacklisted"(value: boolean)
+get "projectAware"(): boolean
+set "authentication"(value: $Authentication$$Type)
+get "authentication"(): $Authentication
+set "layout"(value: $ArtifactRepositoryLayout$$Type)
+set "id"(value: string)
+get "url"(): string
+get "layout"(): $ArtifactRepositoryLayout
+get "releases"(): $ArtifactRepositoryPolicy
+get "snapshots"(): $ArtifactRepositoryPolicy
+set "blocked"(value: boolean)
+get "blocked"(): boolean
+get "proxy"(): $Proxy
+set "proxy"(value: $Proxy$$Type)
+get "basedir"(): string
+set "url"(value: string)
+set "mirroredRepositories"(value: $List$$Type<($ArtifactRepository$$Type)>)
+set "releaseUpdatePolicy"(value: $ArtifactRepositoryPolicy$$Type)
+get "mirroredRepositories"(): $List<($ArtifactRepository)>
+set "snapshotUpdatePolicy"(value: $ArtifactRepositoryPolicy$$Type)
+}
+
+export namespace $ArtifactRepository {
+const probejs$$marker: never
+}
+export class $ArtifactRepository$$Static implements $ArtifactRepository {
+
+
+ "getKey"(): string
+ "find"(arg0: $Artifact$$Type): $Artifact
+ "getId"(): string
+ "getProtocol"(): string
+/**
+ * 
+ * @deprecated
+ */
+ "isUniqueVersion"(): boolean
+/**
+ * 
+ * @deprecated
+ */
+ "isBlacklisted"(): boolean
+/**
+ * 
+ * @deprecated
+ */
+ "setBlacklisted"(arg0: boolean): void
+ "isProjectAware"(): boolean
+ "setAuthentication"(arg0: $Authentication$$Type): void
+ "getAuthentication"(): $Authentication
+ "findVersions"(arg0: $Artifact$$Type): $List<(string)>
+ "pathOfLocalRepositoryMetadata"(arg0: $ArtifactMetadata$$Type, arg1: $ArtifactRepository$$Type): string
+ "pathOfRemoteRepositoryMetadata"(arg0: $ArtifactMetadata$$Type): string
+ "setLayout"(arg0: $ArtifactRepositoryLayout$$Type): void
+ "setId"(arg0: string): void
+ "getUrl"(): string
+ "getLayout"(): $ArtifactRepositoryLayout
+ "getReleases"(): $ArtifactRepositoryPolicy
+ "getSnapshots"(): $ArtifactRepositoryPolicy
+ "setBlocked"(arg0: boolean): void
+ "pathOf"(arg0: $Artifact$$Type): string
+ "isBlocked"(): boolean
+ "getProxy"(): $Proxy
+ "setProxy"(arg0: $Proxy$$Type): void
+ "getBasedir"(): string
+ "setUrl"(arg0: string): void
+ "setMirroredRepositories"(arg0: $List$$Type<($ArtifactRepository$$Type)>): void
+ "setReleaseUpdatePolicy"(arg0: $ArtifactRepositoryPolicy$$Type): void
+ "getMirroredRepositories"(): $List<($ArtifactRepository)>
+ "setSnapshotUpdatePolicy"(arg0: $ArtifactRepositoryPolicy$$Type): void
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $ArtifactRepository$$Type = ($ArtifactRepository);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $ArtifactRepository_ = $ArtifactRepository$$Type;
+}}
+declare module "org.apache.maven.artifact.versioning.ArtifactVersion" {
+import {$Comparable, $Comparable$$Type} from "java.lang.Comparable"
+
+export interface $ArtifactVersion extends $Comparable<($ArtifactVersion)> {
+
+ "getMajorVersion"(): integer
+ "getMinorVersion"(): integer
+ "getIncrementalVersion"(): integer
+ "parseVersion"(arg0: string): void
+ "getQualifier"(): string
+ "getBuildNumber"(): integer
+ "compareTo"(arg0: $ArtifactVersion$$Type): integer
+get "majorVersion"(): integer
+get "minorVersion"(): integer
+get "incrementalVersion"(): integer
+get "qualifier"(): string
+get "buildNumber"(): integer
+}
+
+export namespace $ArtifactVersion {
+const probejs$$marker: never
+}
+export class $ArtifactVersion$$Static implements $ArtifactVersion {
+
+
+ "getMajorVersion"(): integer
+ "getMinorVersion"(): integer
+ "getIncrementalVersion"(): integer
+ "parseVersion"(arg0: string): void
+ "getQualifier"(): string
+ "getBuildNumber"(): integer
+ "compareTo"(arg0: $ArtifactVersion$$Type): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $ArtifactVersion$$Type = ($ArtifactVersion);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $ArtifactVersion_ = $ArtifactVersion$$Type;
+}}
+declare module "org.apache.maven.artifact.resolver.filter.ArtifactFilter" {
+import {$Artifact, $Artifact$$Type} from "org.apache.maven.artifact.Artifact"
+
+export interface $ArtifactFilter {
+
+ "include"(arg0: $Artifact$$Type): boolean
+
+(arg0: $Artifact): boolean
+}
+
+export namespace $ArtifactFilter {
+const probejs$$marker: never
+}
+export class $ArtifactFilter$$Static implements $ArtifactFilter {
+
+
+ "include"(arg0: $Artifact$$Type): boolean
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $ArtifactFilter$$Type = ((arg0: $Artifact) => boolean);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $ArtifactFilter_ = $ArtifactFilter$$Type;
+}}
+declare module "org.apache.commons.lang3.mutable.MutableFloat" {
+import {$Mutable, $Mutable$$Type} from "org.apache.commons.lang3.mutable.Mutable"
+import {$Comparable, $Comparable$$Type} from "java.lang.Comparable"
+
+export class $MutableFloat extends number implements $Comparable<($MutableFloat)>, $Mutable<(number)> {
+
+constructor(arg0: string)
+constructor(arg0: number)
+constructor(arg0: float)
+constructor()
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "isInfinite"(): boolean
+public "compareTo"(arg0: $MutableFloat$$Type): integer
+public "compareTo"(arg0: any): integer
+public "intValue"(): integer
+public "longValue"(): long
+public "floatValue"(): float
+public "doubleValue"(): double
+public "getValue"(): float
+public "add"(arg0: float): void
+public "add"(arg0: number): void
+public "increment"(): void
+public "isNaN"(): boolean
+public "setValue"(arg0: float): void
+public "setValue"(arg0: number): void
+public "setValue"(arg0: any): void
+public "getAndAdd"(arg0: number): float
+public "getAndAdd"(arg0: float): float
+public "incrementAndGet"(): float
+public "getAndIncrement"(): float
+public "getAndDecrement"(): float
+public "decrementAndGet"(): float
+public "addAndGet"(arg0: float): float
+public "addAndGet"(arg0: number): float
+public "subtract"(arg0: float): void
+public "subtract"(arg0: number): void
+public "decrement"(): void
+public "toFloat"(): float
+get "infinite"(): boolean
+get "value"(): float
+get "naN"(): boolean
+set "value"(value: float)
+set "value"(value: number)
+set "value"(value: any)
+get "andIncrement"(): float
+get "andDecrement"(): float
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $MutableFloat$$Type = ($MutableFloat);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $MutableFloat_ = $MutableFloat$$Type;
+}}
+declare module "org.apache.maven.artifact.handler.ArtifactHandler" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $ArtifactHandler {
+
+ "getLanguage"(): string
+ "getExtension"(): string
+ "getPackaging"(): string
+ "isAddedToClasspath"(): boolean
+ "getDirectory"(): string
+ "getClassifier"(): string
+ "isIncludesDependencies"(): boolean
+get "language"(): string
+get "extension"(): string
+get "packaging"(): string
+get "addedToClasspath"(): boolean
+get "directory"(): string
+get "classifier"(): string
+get "includesDependencies"(): boolean
+}
+
+export namespace $ArtifactHandler {
+const ROLE: string
+const probejs$$marker: never
+}
+export class $ArtifactHandler$$Static implements $ArtifactHandler {
+static readonly "ROLE": string
+
+
+ "getLanguage"(): string
+ "getExtension"(): string
+ "getPackaging"(): string
+ "isAddedToClasspath"(): boolean
+ "getDirectory"(): string
+ "getClassifier"(): string
+ "isIncludesDependencies"(): boolean
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $ArtifactHandler$$Type = ($ArtifactHandler);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $ArtifactHandler_ = $ArtifactHandler$$Type;
+}}
+declare module "org.apache.commons.lang3.mutable.Mutable" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $Mutable<T> {
+
+ "getValue"(): T
+ "setValue"(arg0: T): void
+get "value"(): T
+set "value"(value: T)
+}
+
+export namespace $Mutable {
+const probejs$$marker: never
+}
+export class $Mutable$$Static<T> implements $Mutable {
+
+
+ "getValue"(): T
+ "setValue"(arg0: T): void
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Mutable$$Type<T> = ($Mutable<(T)>);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Mutable_<T> = $Mutable$$Type<(T)>;
+}}
+declare module "org.apache.maven.artifact.versioning.Restriction" {
+import {$ArtifactVersion, $ArtifactVersion$$Type} from "org.apache.maven.artifact.versioning.ArtifactVersion"
+
+export class $Restriction {
+static readonly "EVERYTHING": $Restriction
+
+constructor(arg0: $ArtifactVersion$$Type, arg1: boolean, arg2: $ArtifactVersion$$Type, arg3: boolean)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getUpperBound"(): $ArtifactVersion
+public "isUpperBoundInclusive"(): boolean
+public "isLowerBoundInclusive"(): boolean
+public "containsVersion"(arg0: $ArtifactVersion$$Type): boolean
+public "getLowerBound"(): $ArtifactVersion
+get "upperBound"(): $ArtifactVersion
+get "upperBoundInclusive"(): boolean
+get "lowerBoundInclusive"(): boolean
+get "lowerBound"(): $ArtifactVersion
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Restriction$$Type = ($Restriction);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Restriction_ = $Restriction$$Type;
+}}
+declare module "org.apache.maven.artifact.metadata.ArtifactMetadata" {
+import {$ArtifactRepository, $ArtifactRepository$$Type} from "org.apache.maven.artifact.repository.ArtifactRepository"
+import {$ArtifactMetadata as $ArtifactMetadata$0, $ArtifactMetadata$$Type as $ArtifactMetadata$0$$Type} from "org.apache.maven.repository.legacy.metadata.ArtifactMetadata"
+
+/**
+ * 
+ * @deprecated
+ */
+export interface $ArtifactMetadata extends $ArtifactMetadata$0 {
+
+ "merge"(arg0: $ArtifactMetadata$$Type): void
+ "merge"(arg0: $ArtifactMetadata$0$$Type): void
+ "getKey"(): any
+ "getLocalFilename"(arg0: $ArtifactRepository$$Type): string
+ "getRemoteFilename"(): string
+ "extendedToString"(): string
+ "storedInArtifactVersionDirectory"(): boolean
+ "getArtifactId"(): string
+ "getGroupId"(): string
+ "storedInGroupDirectory"(): boolean
+ "storeInLocalRepository"(arg0: $ArtifactRepository$$Type, arg1: $ArtifactRepository$$Type): void
+ "getBaseVersion"(): string
+get "key"(): any
+get "remoteFilename"(): string
+get "artifactId"(): string
+get "groupId"(): string
+get "baseVersion"(): string
+}
+
+export namespace $ArtifactMetadata {
+const probejs$$marker: never
+}
+export class $ArtifactMetadata$$Static implements $ArtifactMetadata {
+
+
+ "merge"(arg0: $ArtifactMetadata$$Type): void
+ "merge"(arg0: $ArtifactMetadata$0$$Type): void
+ "getKey"(): any
+ "getLocalFilename"(arg0: $ArtifactRepository$$Type): string
+ "getRemoteFilename"(): string
+ "extendedToString"(): string
+ "storedInArtifactVersionDirectory"(): boolean
+ "getArtifactId"(): string
+ "getGroupId"(): string
+ "storedInGroupDirectory"(): boolean
+ "storeInLocalRepository"(arg0: $ArtifactRepository$$Type, arg1: $ArtifactRepository$$Type): void
+ "getBaseVersion"(): string
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $ArtifactMetadata$$Type = ($ArtifactMetadata);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $ArtifactMetadata_ = $ArtifactMetadata$$Type;
+}}
+declare module "org.apache.commons.lang3.function.TriConsumer" {
+export {} // Mark the file as a module, do not remove unless there are other import/exports!
+export interface $TriConsumer<T, U, V> {
+
+ "accept"(arg0: T, arg1: U, arg2: V): void
+ "andThen"(arg0: $TriConsumer$$Type<(T), (U), (V)>): $TriConsumer<(T), (U), (V)>
+
+(arg0: T, arg1: U, arg2: V): void
+}
+
+export namespace $TriConsumer {
+const probejs$$marker: never
+}
+export class $TriConsumer$$Static<T, U, V> implements $TriConsumer {
+
+
+ "accept"(arg0: T, arg1: U, arg2: V): void
+ "andThen"(arg0: $TriConsumer$$Type<(T), (U), (V)>): $TriConsumer<(T), (U), (V)>
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $TriConsumer$$Type<T, U, V> = ((arg0: T, arg1: U, arg2: V) => void);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $TriConsumer_<T, U, V> = $TriConsumer$$Type<(T), (U), (V)>;
+}}
+declare module "org.apache.maven.artifact.Artifact" {
+import {$ArtifactFilter, $ArtifactFilter$$Type} from "org.apache.maven.artifact.resolver.filter.ArtifactFilter"
+import {$ArtifactRepository, $ArtifactRepository$$Type} from "org.apache.maven.artifact.repository.ArtifactRepository"
+import {$ArtifactVersion, $ArtifactVersion$$Type} from "org.apache.maven.artifact.versioning.ArtifactVersion"
+import {$Pattern, $Pattern$$Type} from "java.util.regex.Pattern"
+import {$Collection, $Collection$$Type} from "java.util.Collection"
+import {$File, $File$$Type} from "java.io.File"
+import {$Comparable, $Comparable$$Type} from "java.lang.Comparable"
+import {$ArtifactHandler, $ArtifactHandler$$Type} from "org.apache.maven.artifact.handler.ArtifactHandler"
+import {$List, $List$$Type} from "java.util.List"
+import {$VersionRange, $VersionRange$$Type} from "org.apache.maven.artifact.versioning.VersionRange"
+import {$ArtifactMetadata, $ArtifactMetadata$$Type} from "org.apache.maven.artifact.metadata.ArtifactMetadata"
+
+export interface $Artifact extends $Comparable<($Artifact)> {
+
+ "getRepository"(): $ArtifactRepository
+ "getId"(): string
+ "getType"(): string
+ "getScope"(): string
+ "isResolved"(): boolean
+ "setRelease"(arg0: boolean): void
+ "getFile"(): $File
+ "getVersion"(): string
+ "setVersion"(arg0: string): void
+ "getArtifactId"(): string
+ "getClassifier"(): string
+ "getDependencyTrail"(): $List<(string)>
+ "getVersionRange"(): $VersionRange
+ "isSelectedVersionKnown"(): boolean
+ "getSelectedVersion"(): $ArtifactVersion
+ "setFile"(arg0: $File$$Type): void
+ "getGroupId"(): string
+ "setScope"(arg0: string): void
+ "isSnapshot"(): boolean
+ "isOptional"(): boolean
+ "getArtifactHandler"(): $ArtifactHandler
+ "getMetadataList"(): $Collection<($ArtifactMetadata)>
+ "setVersionRange"(arg0: $VersionRange$$Type): void
+ "setDependencyTrail"(arg0: $List$$Type<(string)>): void
+ "setRepository"(arg0: $ArtifactRepository$$Type): void
+ "selectVersion"(arg0: string): void
+ "setArtifactId"(arg0: string): void
+ "updateVersion"(arg0: string, arg1: $ArtifactRepository$$Type): void
+ "setArtifactHandler"(arg0: $ArtifactHandler$$Type): void
+ "setOptional"(arg0: boolean): void
+ "getDownloadUrl"(): string
+ "setBaseVersion"(arg0: string): void
+ "addMetadata"(arg0: $ArtifactMetadata$$Type): void
+ "setDownloadUrl"(arg0: string): void
+ "setResolvedVersion"(arg0: string): void
+ "setResolved"(arg0: boolean): void
+ "hasClassifier"(): boolean
+ "getBaseVersion"(): string
+ "getAvailableVersions"(): $List<($ArtifactVersion)>
+ "setAvailableVersions"(arg0: $List$$Type<($ArtifactVersion$$Type)>): void
+ "getDependencyFilter"(): $ArtifactFilter
+ "getDependencyConflictId"(): string
+ "setDependencyFilter"(arg0: $ArtifactFilter$$Type): void
+ "isRelease"(): boolean
+ "setGroupId"(arg0: string): void
+ "compareTo"(arg0: $Artifact$$Type): integer
+get "repository"(): $ArtifactRepository
+get "id"(): string
+get "type"(): string
+get "scope"(): string
+get "resolved"(): boolean
+set "release"(value: boolean)
+get "file"(): $File
+get "version"(): string
+set "version"(value: string)
+get "artifactId"(): string
+get "classifier"(): string
+get "dependencyTrail"(): $List<(string)>
+get "versionRange"(): $VersionRange
+get "selectedVersionKnown"(): boolean
+get "selectedVersion"(): $ArtifactVersion
+set "file"(value: $File$$Type)
+get "groupId"(): string
+set "scope"(value: string)
+get "snapshot"(): boolean
+get "optional"(): boolean
+get "artifactHandler"(): $ArtifactHandler
+get "metadataList"(): $Collection<($ArtifactMetadata)>
+set "versionRange"(value: $VersionRange$$Type)
+set "dependencyTrail"(value: $List$$Type<(string)>)
+set "repository"(value: $ArtifactRepository$$Type)
+set "artifactId"(value: string)
+set "artifactHandler"(value: $ArtifactHandler$$Type)
+set "optional"(value: boolean)
+get "downloadUrl"(): string
+set "baseVersion"(value: string)
+set "downloadUrl"(value: string)
+set "resolvedVersion"(value: string)
+set "resolved"(value: boolean)
+get "baseVersion"(): string
+get "availableVersions"(): $List<($ArtifactVersion)>
+set "availableVersions"(value: $List$$Type<($ArtifactVersion$$Type)>)
+get "dependencyFilter"(): $ArtifactFilter
+get "dependencyConflictId"(): string
+set "dependencyFilter"(value: $ArtifactFilter$$Type)
+get "release"(): boolean
+set "groupId"(value: string)
+}
+
+export namespace $Artifact {
+const VERSION_FILE_PATTERN: $Pattern
+const SCOPE_RUNTIME: string
+const SCOPE_TEST: string
+const SCOPE_RUNTIME_PLUS_SYSTEM: string
+const SCOPE_IMPORT: string
+const SCOPE_PROVIDED: string
+const RELEASE_VERSION: string
+const SCOPE_SYSTEM: string
+const SNAPSHOT_VERSION: string
+const SCOPE_COMPILE: string
+const SCOPE_COMPILE_PLUS_RUNTIME: string
+const LATEST_VERSION: string
+const probejs$$marker: never
+}
+export class $Artifact$$Static implements $Artifact {
+static readonly "VERSION_FILE_PATTERN": $Pattern
+static readonly "SCOPE_RUNTIME": string
+static readonly "SCOPE_TEST": string
+static readonly "SCOPE_RUNTIME_PLUS_SYSTEM": string
+static readonly "SCOPE_IMPORT": string
+static readonly "SCOPE_PROVIDED": string
+static readonly "RELEASE_VERSION": string
+static readonly "SCOPE_SYSTEM": string
+static readonly "SNAPSHOT_VERSION": string
+static readonly "SCOPE_COMPILE": string
+static readonly "SCOPE_COMPILE_PLUS_RUNTIME": string
+static readonly "LATEST_VERSION": string
+
+
+ "getRepository"(): $ArtifactRepository
+ "getId"(): string
+ "getType"(): string
+ "getScope"(): string
+ "isResolved"(): boolean
+ "setRelease"(arg0: boolean): void
+ "getFile"(): $File
+ "getVersion"(): string
+ "setVersion"(arg0: string): void
+ "getArtifactId"(): string
+ "getClassifier"(): string
+ "getDependencyTrail"(): $List<(string)>
+ "getVersionRange"(): $VersionRange
+ "isSelectedVersionKnown"(): boolean
+ "getSelectedVersion"(): $ArtifactVersion
+ "setFile"(arg0: $File$$Type): void
+ "getGroupId"(): string
+ "setScope"(arg0: string): void
+ "isSnapshot"(): boolean
+ "isOptional"(): boolean
+ "getArtifactHandler"(): $ArtifactHandler
+ "getMetadataList"(): $Collection<($ArtifactMetadata)>
+ "setVersionRange"(arg0: $VersionRange$$Type): void
+ "setDependencyTrail"(arg0: $List$$Type<(string)>): void
+ "setRepository"(arg0: $ArtifactRepository$$Type): void
+ "selectVersion"(arg0: string): void
+ "setArtifactId"(arg0: string): void
+ "updateVersion"(arg0: string, arg1: $ArtifactRepository$$Type): void
+ "setArtifactHandler"(arg0: $ArtifactHandler$$Type): void
+ "setOptional"(arg0: boolean): void
+ "getDownloadUrl"(): string
+ "setBaseVersion"(arg0: string): void
+ "addMetadata"(arg0: $ArtifactMetadata$$Type): void
+ "setDownloadUrl"(arg0: string): void
+ "setResolvedVersion"(arg0: string): void
+ "setResolved"(arg0: boolean): void
+ "hasClassifier"(): boolean
+ "getBaseVersion"(): string
+ "getAvailableVersions"(): $List<($ArtifactVersion)>
+ "setAvailableVersions"(arg0: $List$$Type<($ArtifactVersion$$Type)>): void
+ "getDependencyFilter"(): $ArtifactFilter
+ "getDependencyConflictId"(): string
+ "setDependencyFilter"(arg0: $ArtifactFilter$$Type): void
+ "isRelease"(): boolean
+ "setGroupId"(arg0: string): void
+ "compareTo"(arg0: $Artifact$$Type): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Artifact$$Type = ($Artifact);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Artifact_ = $Artifact$$Type;
+}}
+declare module "org.apache.commons.lang3.mutable.MutableObject" {
+import {$Mutable, $Mutable$$Type} from "org.apache.commons.lang3.mutable.Mutable"
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+
+export class $MutableObject<T> implements $Mutable<(T)>, $Serializable {
+
+constructor()
+constructor(arg0: T)
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "getValue"(): T
+public "setValue"(arg0: T): void
+get "value"(): T
+set "value"(value: T)
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $MutableObject$$Type<T> = ($MutableObject<(T)>);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $MutableObject_<T> = $MutableObject$$Type<(T)>;
+}}
+declare module "org.apache.maven.artifact.versioning.VersionRange" {
+import {$Restriction, $Restriction$$Type} from "org.apache.maven.artifact.versioning.Restriction"
+import {$ArtifactVersion, $ArtifactVersion$$Type} from "org.apache.maven.artifact.versioning.ArtifactVersion"
+import {$List, $List$$Type} from "java.util.List"
+import {$Artifact, $Artifact$$Type} from "org.apache.maven.artifact.Artifact"
+
+export class $VersionRange {
+
+
+public "equals"(arg0: any): boolean
+public "toString"(): string
+public "hashCode"(): integer
+public "isSelectedVersionKnown"(arg0: $Artifact$$Type): boolean
+public "getRecommendedVersion"(): $ArtifactVersion
+public static "createFromVersionSpec"(arg0: string): $VersionRange
+public "getRestrictions"(): $List<($Restriction)>
+public "getSelectedVersion"(arg0: $Artifact$$Type): $ArtifactVersion
+public static "createFromVersion"(arg0: string): $VersionRange
+public "containsVersion"(arg0: $ArtifactVersion$$Type): boolean
+public "matchVersion"(arg0: $List$$Type<($ArtifactVersion$$Type)>): $ArtifactVersion
+public "hasRestrictions"(): boolean
+/**
+ * 
+ * @deprecated
+ */
+public "cloneOf"(): $VersionRange
+public "restrict"(arg0: $VersionRange$$Type): $VersionRange
+get "recommendedVersion"(): $ArtifactVersion
+get "restrictions"(): $List<($Restriction)>
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $VersionRange$$Type = ($VersionRange);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $VersionRange_ = $VersionRange$$Type;
+}}

.probe/startup/probe-types/packages/org.slf4j.d.ts

@@ -0,0 +1,323 @@
+declare module "org.slf4j.spi.LoggingEventBuilder" {
+import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
+import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
+import {$Marker, $Marker$$Type} from "org.slf4j.Marker"
+
+export interface $LoggingEventBuilder {
+
+ "log"(): void
+ "log"(arg0: string): void
+ "log"(arg0: string, arg1: any): void
+ "log"(arg0: $Supplier$$Type<(string)>): void
+ "log"(arg0: string, ...arg1: (any)[]): void
+ "log"(arg0: string, arg1: any, arg2: any): void
+ "setCause"(arg0: $Throwable$$Type): $LoggingEventBuilder
+ "addArgument"(arg0: any): $LoggingEventBuilder
+ "addArgument"(arg0: $Supplier$$Type<(any)>): $LoggingEventBuilder
+ "addKeyValue"(arg0: string, arg1: $Supplier$$Type<(any)>): $LoggingEventBuilder
+ "addKeyValue"(arg0: string, arg1: any): $LoggingEventBuilder
+ "addMarker"(arg0: $Marker$$Type): $LoggingEventBuilder
+ "setMessage"(arg0: $Supplier$$Type<(string)>): $LoggingEventBuilder
+ "setMessage"(arg0: string): $LoggingEventBuilder
+set "cause"(value: $Throwable$$Type)
+set "message"(value: $Supplier$$Type<(string)>)
+set "message"(value: string)
+}
+
+export namespace $LoggingEventBuilder {
+const probejs$$marker: never
+}
+export class $LoggingEventBuilder$$Static implements $LoggingEventBuilder {
+
+
+ "log"(): void
+ "log"(arg0: string): void
+ "log"(arg0: string, arg1: any): void
+ "log"(arg0: $Supplier$$Type<(string)>): void
+ "log"(arg0: string, ...arg1: (any)[]): void
+ "log"(arg0: string, arg1: any, arg2: any): void
+ "setCause"(arg0: $Throwable$$Type): $LoggingEventBuilder
+ "addArgument"(arg0: any): $LoggingEventBuilder
+ "addArgument"(arg0: $Supplier$$Type<(any)>): $LoggingEventBuilder
+ "addKeyValue"(arg0: string, arg1: $Supplier$$Type<(any)>): $LoggingEventBuilder
+ "addKeyValue"(arg0: string, arg1: any): $LoggingEventBuilder
+ "addMarker"(arg0: $Marker$$Type): $LoggingEventBuilder
+ "setMessage"(arg0: $Supplier$$Type<(string)>): $LoggingEventBuilder
+ "setMessage"(arg0: string): $LoggingEventBuilder
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $LoggingEventBuilder$$Type = ($LoggingEventBuilder);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $LoggingEventBuilder_ = $LoggingEventBuilder$$Type;
+}}
+declare module "org.slf4j.event.Level" {
+import {$Enum, $Enum$$Type} from "java.lang.Enum"
+
+export class $Level extends $Enum<($Level)> {
+static readonly "TRACE": $Level
+static readonly "ERROR": $Level
+static readonly "INFO": $Level
+static readonly "DEBUG": $Level
+static readonly "WARN": $Level
+
+
+public "toString"(): string
+public static "values"(): ($Level)[]
+public static "valueOf"(arg0: string): $Level
+public "toInt"(): integer
+public static "intToLevel"(arg0: integer): $Level
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Level$$Type = (("error") | ("warn") | ("info") | ("debug") | ("trace"));
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Level_ = $Level$$Type;
+}}
+declare module "org.slf4j.Logger" {
+import {$LoggingEventBuilder, $LoggingEventBuilder$$Type} from "org.slf4j.spi.LoggingEventBuilder"
+import {$Level, $Level$$Type} from "org.slf4j.event.Level"
+import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
+import {$Marker, $Marker$$Type} from "org.slf4j.Marker"
+
+export interface $Logger {
+
+ "getName"(): string
+ "info"(arg0: string, arg1: any, arg2: any): void
+ "info"(arg0: string, ...arg1: (any)[]): void
+ "info"(arg0: string, arg1: $Throwable$$Type): void
+ "info"(arg0: string, arg1: any): void
+ "info"(arg0: string): void
+ "info"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "info"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "info"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "info"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "info"(arg0: $Marker$$Type, arg1: string): void
+ "trace"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "trace"(arg0: string, arg1: any): void
+ "trace"(arg0: string, ...arg1: (any)[]): void
+ "trace"(arg0: string): void
+ "trace"(arg0: string, arg1: $Throwable$$Type): void
+ "trace"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "trace"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "trace"(arg0: $Marker$$Type, arg1: string): void
+ "trace"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "trace"(arg0: string, arg1: any, arg2: any): void
+ "debug"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "debug"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "debug"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "debug"(arg0: string, ...arg1: (any)[]): void
+ "debug"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "debug"(arg0: string): void
+ "debug"(arg0: string, arg1: any): void
+ "debug"(arg0: string, arg1: any, arg2: any): void
+ "debug"(arg0: string, arg1: $Throwable$$Type): void
+ "debug"(arg0: $Marker$$Type, arg1: string): void
+ "error"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "error"(arg0: string, arg1: any, arg2: any): void
+ "error"(arg0: string, arg1: any): void
+ "error"(arg0: string): void
+ "error"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "error"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "error"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "error"(arg0: string, ...arg1: (any)[]): void
+ "error"(arg0: string, arg1: $Throwable$$Type): void
+ "error"(arg0: $Marker$$Type, arg1: string): void
+ "warn"(arg0: string, arg1: $Throwable$$Type): void
+ "warn"(arg0: string, arg1: any, arg2: any): void
+ "warn"(arg0: string, ...arg1: (any)[]): void
+ "warn"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "warn"(arg0: $Marker$$Type, arg1: string): void
+ "warn"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "warn"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "warn"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "warn"(arg0: string): void
+ "warn"(arg0: string, arg1: any): void
+ "isEnabledForLevel"(arg0: $Level$$Type): boolean
+ "isInfoEnabled"(): boolean
+ "isInfoEnabled"(arg0: $Marker$$Type): boolean
+ "isErrorEnabled"(arg0: $Marker$$Type): boolean
+ "isErrorEnabled"(): boolean
+ "isTraceEnabled"(): boolean
+ "isTraceEnabled"(arg0: $Marker$$Type): boolean
+ "isWarnEnabled"(arg0: $Marker$$Type): boolean
+ "isWarnEnabled"(): boolean
+ "isDebugEnabled"(): boolean
+ "isDebugEnabled"(arg0: $Marker$$Type): boolean
+ "makeLoggingEventBuilder"(arg0: $Level$$Type): $LoggingEventBuilder
+ "atInfo"(): $LoggingEventBuilder
+ "atLevel"(arg0: $Level$$Type): $LoggingEventBuilder
+ "atDebug"(): $LoggingEventBuilder
+ "atWarn"(): $LoggingEventBuilder
+ "atError"(): $LoggingEventBuilder
+ "atTrace"(): $LoggingEventBuilder
+get "name"(): string
+get "infoEnabled"(): boolean
+get "errorEnabled"(): boolean
+get "traceEnabled"(): boolean
+get "warnEnabled"(): boolean
+get "debugEnabled"(): boolean
+}
+
+export namespace $Logger {
+const ROOT_LOGGER_NAME: string
+const probejs$$marker: never
+}
+export class $Logger$$Static implements $Logger {
+static readonly "ROOT_LOGGER_NAME": string
+
+
+ "getName"(): string
+ "info"(arg0: string, arg1: any, arg2: any): void
+ "info"(arg0: string, ...arg1: (any)[]): void
+ "info"(arg0: string, arg1: $Throwable$$Type): void
+ "info"(arg0: string, arg1: any): void
+ "info"(arg0: string): void
+ "info"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "info"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "info"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "info"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "info"(arg0: $Marker$$Type, arg1: string): void
+ "trace"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "trace"(arg0: string, arg1: any): void
+ "trace"(arg0: string, ...arg1: (any)[]): void
+ "trace"(arg0: string): void
+ "trace"(arg0: string, arg1: $Throwable$$Type): void
+ "trace"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "trace"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "trace"(arg0: $Marker$$Type, arg1: string): void
+ "trace"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "trace"(arg0: string, arg1: any, arg2: any): void
+ "debug"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "debug"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "debug"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "debug"(arg0: string, ...arg1: (any)[]): void
+ "debug"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "debug"(arg0: string): void
+ "debug"(arg0: string, arg1: any): void
+ "debug"(arg0: string, arg1: any, arg2: any): void
+ "debug"(arg0: string, arg1: $Throwable$$Type): void
+ "debug"(arg0: $Marker$$Type, arg1: string): void
+ "error"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "error"(arg0: string, arg1: any, arg2: any): void
+ "error"(arg0: string, arg1: any): void
+ "error"(arg0: string): void
+ "error"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "error"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "error"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "error"(arg0: string, ...arg1: (any)[]): void
+ "error"(arg0: string, arg1: $Throwable$$Type): void
+ "error"(arg0: $Marker$$Type, arg1: string): void
+ "warn"(arg0: string, arg1: $Throwable$$Type): void
+ "warn"(arg0: string, arg1: any, arg2: any): void
+ "warn"(arg0: string, ...arg1: (any)[]): void
+ "warn"(arg0: $Marker$$Type, arg1: string, arg2: any): void
+ "warn"(arg0: $Marker$$Type, arg1: string): void
+ "warn"(arg0: $Marker$$Type, arg1: string, arg2: $Throwable$$Type): void
+ "warn"(arg0: $Marker$$Type, arg1: string, ...arg2: (any)[]): void
+ "warn"(arg0: $Marker$$Type, arg1: string, arg2: any, arg3: any): void
+ "warn"(arg0: string): void
+ "warn"(arg0: string, arg1: any): void
+ "isEnabledForLevel"(arg0: $Level$$Type): boolean
+ "isInfoEnabled"(): boolean
+ "isInfoEnabled"(arg0: $Marker$$Type): boolean
+ "isErrorEnabled"(arg0: $Marker$$Type): boolean
+ "isErrorEnabled"(): boolean
+ "isTraceEnabled"(): boolean
+ "isTraceEnabled"(arg0: $Marker$$Type): boolean
+ "isWarnEnabled"(arg0: $Marker$$Type): boolean
+ "isWarnEnabled"(): boolean
+ "isDebugEnabled"(): boolean
+ "isDebugEnabled"(arg0: $Marker$$Type): boolean
+ "makeLoggingEventBuilder"(arg0: $Level$$Type): $LoggingEventBuilder
+ "atInfo"(): $LoggingEventBuilder
+ "atLevel"(arg0: $Level$$Type): $LoggingEventBuilder
+ "atDebug"(): $LoggingEventBuilder
+ "atWarn"(): $LoggingEventBuilder
+ "atError"(): $LoggingEventBuilder
+ "atTrace"(): $LoggingEventBuilder
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Logger$$Type = ($Logger);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Logger_ = $Logger$$Type;
+}}
+declare module "org.slf4j.Marker" {
+import {$Iterator, $Iterator$$Type} from "java.util.Iterator"
+import {$Serializable, $Serializable$$Type} from "java.io.Serializable"
+
+export interface $Marker extends $Serializable {
+
+ "getName"(): string
+ "remove"(arg0: $Marker$$Type): boolean
+ "equals"(arg0: any): boolean
+ "hashCode"(): integer
+ "add"(arg0: $Marker$$Type): void
+ "iterator"(): $Iterator<($Marker)>
+ "contains"(arg0: string): boolean
+ "contains"(arg0: $Marker$$Type): boolean
+ "hasReferences"(): boolean
+/**
+ * 
+ * @deprecated
+ */
+ "hasChildren"(): boolean
+get "name"(): string
+}
+
+export namespace $Marker {
+const ANY_MARKER: string
+const ANY_NON_NULL_MARKER: string
+const probejs$$marker: never
+}
+export class $Marker$$Static implements $Marker {
+static readonly "ANY_MARKER": string
+static readonly "ANY_NON_NULL_MARKER": string
+
+
+ "getName"(): string
+ "remove"(arg0: $Marker$$Type): boolean
+ "equals"(arg0: any): boolean
+ "hashCode"(): integer
+ "add"(arg0: $Marker$$Type): void
+ "iterator"(): $Iterator<($Marker)>
+ "contains"(arg0: string): boolean
+ "contains"(arg0: $Marker$$Type): boolean
+ "hasReferences"(): boolean
+/**
+ * 
+ * @deprecated
+ */
+ "hasChildren"(): boolean
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $Marker$$Type = ($Marker);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $Marker_ = $Marker$$Type;
+}}

.probe/startup/probe-types/packages/org.spongepowered.d.ts

@@ -0,0 +1,89 @@
+declare module "org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable" {
+import {$CallbackInfo, $CallbackInfo$$Type} from "org.spongepowered.asm.mixin.injection.callback.CallbackInfo"
+
+/**
+ * This class is not allowed By KubeJS!
+ * You should not load the class, or KubeJS will throw an error.
+ * Loading the class using require() will not throw an error, but the class will be undefined.
+ */
+export class $CallbackInfoReturnable<R> extends $CallbackInfo {
+
+constructor(arg0: string, arg1: boolean, arg2: float)
+constructor(arg0: string, arg1: boolean, arg2: integer)
+constructor(arg0: string, arg1: boolean, arg2: long)
+constructor(arg0: string, arg1: boolean, arg2: short)
+constructor(arg0: string, arg1: boolean, arg2: boolean)
+constructor(arg0: string, arg1: boolean)
+constructor(arg0: string, arg1: boolean, arg2: R)
+constructor(arg0: string, arg1: boolean, arg2: byte)
+constructor(arg0: string, arg1: boolean, arg2: character)
+constructor(arg0: string, arg1: boolean, arg2: double)
+
+public "getReturnValueD"(): double
+public "getReturnValueJ"(): long
+public "getReturnValueB"(): byte
+public "getReturnValueS"(): short
+public "getReturnValueZ"(): boolean
+public "setReturnValue"(arg0: R): void
+public "getReturnValue"(): R
+public "getReturnValueC"(): character
+public "getReturnValueF"(): float
+public "getReturnValueI"(): integer
+get "returnValueD"(): double
+get "returnValueJ"(): long
+get "returnValueB"(): byte
+get "returnValueS"(): short
+get "returnValueZ"(): boolean
+set "returnValue"(value: R)
+get "returnValue"(): R
+get "returnValueC"(): character
+get "returnValueF"(): float
+get "returnValueI"(): integer
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $CallbackInfoReturnable$$Type<R> = ($CallbackInfoReturnable<(R)>);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $CallbackInfoReturnable_<R> = $CallbackInfoReturnable$$Type<(R)>;
+}}
+declare module "org.spongepowered.asm.mixin.injection.callback.CallbackInfo" {
+import {$Cancellable, $Cancellable$$Type} from "org.spongepowered.asm.mixin.injection.callback.Cancellable"
+import {$Type, $Type$$Type} from "org.objectweb.asm.Type"
+
+/**
+ * This class is not allowed By KubeJS!
+ * You should not load the class, or KubeJS will throw an error.
+ * Loading the class using require() will not throw an error, but the class will be undefined.
+ */
+export class $CallbackInfo implements $Cancellable {
+
+constructor(arg0: string, arg1: boolean)
+
+public "toString"(): string
+public "getId"(): string
+public "cancel"(): void
+public "isCancelled"(): boolean
+public "isCancellable"(): boolean
+public static "getCallInfoClassName"(arg0: $Type$$Type): string
+get "id"(): string
+get "cancelled"(): boolean
+get "cancellable"(): boolean
+}
+/**
+ * Class-specific type exported by ProbeJS, use global Type_
+ * types for convenience unless there's a naming conflict.
+ */
+export type $CallbackInfo$$Type = ($CallbackInfo);
+/**
+ * Global type exported for convenience, use class-specific
+ * types if there's a naming conflict.
+ */
+declare global {
+export type $CallbackInfo_ = $CallbackInfo$$Type;
+}}