open-index/open-npm huggingface dataset:
npm package: @minecraft-types/yarn-25w04a
Description: Typescript definitions for Minecraft 25w04a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w04a

Typescript definitions for Minecraft 25w04a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w04a
# or
pnpm add @minecraft-types/yarn-25w04a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w04a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w04a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w05a
Description: Typescript definitions for Minecraft 25w05a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w05a

Typescript definitions for Minecraft 25w05a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w05a
# or
pnpm add @minecraft-types/yarn-25w05a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w05a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w05a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w06a
Description: Typescript definitions for Minecraft 25w06a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w06a

Typescript definitions for Minecraft 25w06a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w06a
# or
pnpm add @minecraft-types/yarn-25w06a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w06a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w06a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w07a
Description: Typescript definitions for Minecraft 25w07a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w07a

Typescript definitions for Minecraft 25w07a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w07a
# or
pnpm add @minecraft-types/yarn-25w07a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w07a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w07a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w08a
Description: Typescript definitions for Minecraft 25w08a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w08a

Typescript definitions for Minecraft 25w08a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w08a
# or
pnpm add @minecraft-types/yarn-25w08a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w08a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w08a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w09a
Description: Typescript definitions for Minecraft 25w09a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w09a

Typescript definitions for Minecraft 25w09a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w09a
# or
pnpm add @minecraft-types/yarn-25w09a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w09a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w09a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w09b
Description: Typescript definitions for Minecraft 25w09b (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w09b

Typescript definitions for Minecraft 25w09b (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w09b
# or
pnpm add @minecraft-types/yarn-25w09b
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w09b"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w09b/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w10a
Description: Typescript definitions for Minecraft 25w10a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w10a

Typescript definitions for Minecraft 25w10a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w10a
# or
pnpm add @minecraft-types/yarn-25w10a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w10a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w10a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w14craftmine
Description: Typescript definitions for Minecraft 25w14craftmine (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w14craftmine

Typescript definitions for Minecraft 25w14craftmine (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w14craftmine
# or
pnpm add @minecraft-types/yarn-25w14craftmine
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w14craftmine"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w14craftmine/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w15a
Description: Typescript definitions for Minecraft 25w15a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w15a

Typescript definitions for Minecraft 25w15a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w15a
# or
pnpm add @minecraft-types/yarn-25w15a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w15a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w15a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w16a
Description: Typescript definitions for Minecraft 25w16a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w16a

Typescript definitions for Minecraft 25w16a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w16a
# or
pnpm add @minecraft-types/yarn-25w16a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w16a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w16a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w17a
Description: Typescript definitions for Minecraft 25w17a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w17a

Typescript definitions for Minecraft 25w17a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w17a
# or
pnpm add @minecraft-types/yarn-25w17a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w17a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w17a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w18a
Description: Typescript definitions for Minecraft 25w18a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w18a

Typescript definitions for Minecraft 25w18a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w18a
# or
pnpm add @minecraft-types/yarn-25w18a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w18a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w18a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w19a
Description: Typescript definitions for Minecraft 25w19a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w19a

Typescript definitions for Minecraft 25w19a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w19a
# or
pnpm add @minecraft-types/yarn-25w19a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w19a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w19a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w20a
Description: Typescript definitions for Minecraft 25w20a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w20a

Typescript definitions for Minecraft 25w20a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w20a
# or
pnpm add @minecraft-types/yarn-25w20a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w20a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w20a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w21a
Description: Typescript definitions for Minecraft 25w21a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w21a

Typescript definitions for Minecraft 25w21a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w21a
# or
pnpm add @minecraft-types/yarn-25w21a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w21a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w21a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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
npm package: @minecraft-types/yarn-25w31a
Description: Typescript definitions for Minecraft 25w31a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-25w31a

Typescript definitions for Minecraft 25w31a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-25w31a
# or
pnpm add @minecraft-types/yarn-25w31a
```

Then, in your `tsconfig.json`, add the following to the `compilerOptions` section:

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w31a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-25w31a/build.<BUILD_NUMBER>"
    ]
  }
}
```

Replace `<BUILD_NUMBER>` with the desired build number.

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