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

# @minecraft-types/java.sql.rowset

TypeScript type definitions for the JVM `java.sql.rowset` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/java.sql.rowset
# or
pnpm add @minecraft-types/java.sql.rowset
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/java.sql.rowset"
    ]
  }
}
```

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/java.transaction.xa
Description: Typescript definitions for java.transaction.xa from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/java.transaction.xa

TypeScript type definitions for the JVM `java.transaction.xa` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/java.transaction.xa
# or
pnpm add @minecraft-types/java.transaction.xa
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/java.transaction.xa"
    ]
  }
}
```

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/java.xml
Description: Typescript definitions for java.xml from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/java.xml

TypeScript type definitions for the JVM `java.xml` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/java.xml
# or
pnpm add @minecraft-types/java.xml
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/java.xml"
    ]
  }
}
```

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/java.xml.crypto
Description: Typescript definitions for java.xml.crypto from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/java.xml.crypto

TypeScript type definitions for the JVM `java.xml.crypto` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/java.xml.crypto
# or
pnpm add @minecraft-types/java.xml.crypto
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/java.xml.crypto"
    ]
  }
}
```

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.accessibility
Description: Typescript definitions for jdk.accessibility from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.accessibility

TypeScript type definitions for the JVM `jdk.accessibility` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.accessibility
# or
pnpm add @minecraft-types/jdk.accessibility
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.accessibility"
    ]
  }
}
```

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.attach
Description: Typescript definitions for jdk.attach from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.attach

TypeScript type definitions for the JVM `jdk.attach` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.attach
# or
pnpm add @minecraft-types/jdk.attach
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.attach"
    ]
  }
}
```

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.charsets
Description: Typescript definitions for jdk.charsets from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.charsets

TypeScript type definitions for the JVM `jdk.charsets` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.charsets
# or
pnpm add @minecraft-types/jdk.charsets
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.charsets"
    ]
  }
}
```

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.compiler
Description: Typescript definitions for jdk.compiler from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.compiler

TypeScript type definitions for the JVM `jdk.compiler` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.compiler
# or
pnpm add @minecraft-types/jdk.compiler
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.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.crypto.cryptoki
Description: Typescript definitions for jdk.crypto.cryptoki from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.crypto.cryptoki

TypeScript type definitions for the JVM `jdk.crypto.cryptoki` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.crypto.cryptoki
# or
pnpm add @minecraft-types/jdk.crypto.cryptoki
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.crypto.cryptoki"
    ]
  }
}
```

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.crypto.ec
Description: Typescript definitions for jdk.crypto.ec from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.crypto.ec

TypeScript type definitions for the JVM `jdk.crypto.ec` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.crypto.ec
# or
pnpm add @minecraft-types/jdk.crypto.ec
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.crypto.ec"
    ]
  }
}
```

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.crypto.mscapi
Description: Typescript definitions for jdk.crypto.mscapi from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.crypto.mscapi

TypeScript type definitions for the JVM `jdk.crypto.mscapi` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.crypto.mscapi
# or
pnpm add @minecraft-types/jdk.crypto.mscapi
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.crypto.mscapi"
    ]
  }
}
```

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.dynalink
Description: Typescript definitions for jdk.dynalink from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.dynalink

TypeScript type definitions for the JVM `jdk.dynalink` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.dynalink
# or
pnpm add @minecraft-types/jdk.dynalink
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.dynalink"
    ]
  }
}
```

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.editpad
Description: Typescript definitions for jdk.editpad from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.editpad

TypeScript type definitions for the JVM `jdk.editpad` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.editpad
# or
pnpm add @minecraft-types/jdk.editpad
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.editpad"
    ]
  }
}
```

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.graal.compiler
Description: Typescript definitions for jdk.graal.compiler from JDK 22.0.2.
Author: East_Arctica
Latest version: 22.0.2

﻿# @minecraft-types/jdk.graal.compiler

TypeScript definitions for `jdk.graal.compiler` from JDK `22.0.2\`.

## Install

Install the package via npm or pnpm:

```bash
npm install @minecraft-types/jdk.graal.compiler
# or
pnpm add @minecraft-types/jdk.graal.compiler
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "typeRoots": [
      "node_modules/@minecraft-types/",
      "node_modules/@types"
    ]
  }
}
```

## License

CC0-1.0
npm package: @minecraft-types/jdk.graal.compiler.management
Description: Typescript definitions for jdk.graal.compiler.management from JDK 22.0.2.
Author: East_Arctica
Latest version: 22.0.2

﻿# @minecraft-types/jdk.graal.compiler.management

TypeScript definitions for `jdk.graal.compiler.management` from JDK `22.0.2\`.

## Install

Install the package via npm or pnpm:

```bash
npm install @minecraft-types/jdk.graal.compiler.management
# or
pnpm add @minecraft-types/jdk.graal.compiler.management
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "typeRoots": [
      "node_modules/@minecraft-types/",
      "node_modules/@types"
    ]
  }
}
```

## License

CC0-1.0
npm package: @minecraft-types/jdk.hotspot.agent
Description: Typescript definitions for jdk.hotspot.agent from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.hotspot.agent

TypeScript type definitions for the JVM `jdk.hotspot.agent` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.hotspot.agent
# or
pnpm add @minecraft-types/jdk.hotspot.agent
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.hotspot.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.httpserver
Description: Typescript definitions for jdk.httpserver from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.httpserver

TypeScript type definitions for the JVM `jdk.httpserver` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.httpserver
# or
pnpm add @minecraft-types/jdk.httpserver
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.httpserver"
    ]
  }
}
```

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.incubator.vector
Description: Typescript definitions for jdk.incubator.vector from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.incubator.vector

TypeScript type definitions for the JVM `jdk.incubator.vector` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.incubator.vector
# or
pnpm add @minecraft-types/jdk.incubator.vector
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.incubator.vector"
    ]
  }
}
```

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.ed
Description: Typescript definitions for jdk.internal.ed from JDK 21.0.8.
Author: East_Arctica
Latest version: 1.0.0

# @minecraft-types/jdk.internal.ed

TypeScript type definitions for the JVM `jdk.internal.ed` module (JDK 21.0.8).

## Install

Install from npm or pnpm:

```bash
npm install @minecraft-types/jdk.internal.ed
# or
pnpm add @minecraft-types/jdk.internal.ed
```

## Setup
In your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/jdk.internal.ed"
    ]
  }
}
```

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/)