open-index/open-npm huggingface dataset:
npm package: @minecraft-types/jdk.internal.jvmstat
Description: Typescript definitions for jdk.internal.jvmstat from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.internal.jvmstat

TypeScript type definitions for the JVM `jdk.internal.jvmstat` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.internal.jvmstat
# or
pnpm add @minecraft-types/jdk.internal.jvmstat
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.internal.jvmstat"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.internal.le
Description: Typescript definitions for jdk.internal.le from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.internal.le

TypeScript type definitions for the JVM `jdk.internal.le` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.internal.le
# or
pnpm add @minecraft-types/jdk.internal.le
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.internal.le"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.internal.opt
Description: Typescript definitions for jdk.internal.opt from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.internal.opt

TypeScript type definitions for the JVM `jdk.internal.opt` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.internal.opt
# or
pnpm add @minecraft-types/jdk.internal.opt
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.internal.opt"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.internal.vm.ci
Description: Typescript definitions for jdk.internal.vm.ci from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.internal.vm.ci

TypeScript type definitions for the JVM `jdk.internal.vm.ci` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.internal.vm.ci
# or
pnpm add @minecraft-types/jdk.internal.vm.ci
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.internal.vm.ci"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.internal.vm.compiler
Description: Typescript definitions for jdk.internal.vm.compiler from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.internal.vm.compiler

TypeScript type definitions for the JVM `jdk.internal.vm.compiler` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.internal.vm.compiler
# or
pnpm add @minecraft-types/jdk.internal.vm.compiler
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.internal.vm.compiler"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.internal.vm.compiler.management
Description: Typescript definitions for jdk.internal.vm.compiler.management from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.internal.vm.compiler.management

TypeScript type definitions for the JVM `jdk.internal.vm.compiler.management` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.internal.vm.compiler.management
# or
pnpm add @minecraft-types/jdk.internal.vm.compiler.management
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.internal.vm.compiler.management"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jartool
Description: Typescript definitions for jdk.jartool from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jartool

TypeScript type definitions for the JVM `jdk.jartool` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jartool
# or
pnpm add @minecraft-types/jdk.jartool
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jartool"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.javadoc
Description: Typescript definitions for jdk.javadoc from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.javadoc

TypeScript type definitions for the JVM `jdk.javadoc` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.javadoc
# or
pnpm add @minecraft-types/jdk.javadoc
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.javadoc"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jcmd
Description: Typescript definitions for jdk.jcmd from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jcmd

TypeScript type definitions for the JVM `jdk.jcmd` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jcmd
# or
pnpm add @minecraft-types/jdk.jcmd
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jcmd"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jconsole
Description: Typescript definitions for jdk.jconsole from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jconsole

TypeScript type definitions for the JVM `jdk.jconsole` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jconsole
# or
pnpm add @minecraft-types/jdk.jconsole
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jconsole"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jdeps
Description: Typescript definitions for jdk.jdeps from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jdeps

TypeScript type definitions for the JVM `jdk.jdeps` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jdeps
# or
pnpm add @minecraft-types/jdk.jdeps
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jdeps"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jdi
Description: Typescript definitions for jdk.jdi from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jdi

TypeScript type definitions for the JVM `jdk.jdi` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jdi
# or
pnpm add @minecraft-types/jdk.jdi
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jdi"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jdwp.agent
Description: Typescript definitions for jdk.jdwp.agent from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jdwp.agent

TypeScript type definitions for the JVM `jdk.jdwp.agent` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jdwp.agent
# or
pnpm add @minecraft-types/jdk.jdwp.agent
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jdwp.agent"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jfr
Description: Typescript definitions for jdk.jfr from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jfr

TypeScript type definitions for the JVM `jdk.jfr` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jfr
# or
pnpm add @minecraft-types/jdk.jfr
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jfr"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jlink
Description: Typescript definitions for jdk.jlink from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jlink

TypeScript type definitions for the JVM `jdk.jlink` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jlink
# or
pnpm add @minecraft-types/jdk.jlink
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jlink"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jpackage
Description: Typescript definitions for jdk.jpackage from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jpackage

TypeScript type definitions for the JVM `jdk.jpackage` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jpackage
# or
pnpm add @minecraft-types/jdk.jpackage
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jpackage"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jshell
Description: Typescript definitions for jdk.jshell from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jshell

TypeScript type definitions for the JVM `jdk.jshell` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jshell
# or
pnpm add @minecraft-types/jdk.jshell
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jshell"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)
npm package: @minecraft-types/jdk.jsobject
Description: Typescript definitions for jdk.jsobject from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.jsobject

TypeScript type definitions for the JVM `jdk.jsobject` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.jsobject
# or
pnpm add @minecraft-types/jdk.jsobject
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.jsobject"
    ]
  }
}
```

Note: adding the `types` array explicitly tells TypeScript which global type packages to include. When you set `compilerOptions.types` it will only include the packages listed there and will not automatically include other `@types/*` packages (for example `node`). If you need other ambient types, add them to the array as well or consider using `typeRoots` or a project `global.d.ts` instead.

## Using the types and handling globals

By default, this will expose the types under the `Packages` namespace (ex. `Packages.java.io.BufferedInputStream`).

If you work in an environment where the global namespace is polluted differently with Java types, you can re-namespace the types by creating a `global.d.ts` file in your project with the following content:

```ts
// global.d.ts
declare global {
  const java: typeof Packages.java;
  // Add other root namespaces as needed (e.g., javax, com, org, etc.)
  // const com: typeof Packages.com;

  // If your environment exposes something other than 'Packages', you can alias it here
  // const SomeOtherPackages: typeof Packages;
}

export {}; // keep file a module so TS merges properly
```

If instead, you'd prefer to only pollute the global namespace within that file, you can add the following to your typescript files:
```ts
declare const java: typeof Packages.java;
// Add other root namespaces as needed (e.g., javax, com, org, etc.)
// declare const com: typeof Packages.com;

// If your environment exposes something other than 'Packages', you can alias it here
// declare const SomeOtherPackages: typeof Packages;
```

## Examples

- Referencing a Java type directly from the ambient `Packages` types:

```ts
// Uses the package name as exposed by the types
type BIS = Packages.java.io.BufferedInputStream;

declare const inStream: BIS;
```

- Using the `java` alias from the `global.d.ts` example:

```ts
const s: string = java.lang.String.valueOf(123);
```

## License

[CC0-1.0](https://creativecommons.org/publicdomain/zero/1.0/)