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

# @minecraft-types/yarn-20w19a

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

## Usage

Install from npm or pnpm:

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

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

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

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w19a/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-20w20a
Description: Typescript definitions for Minecraft 20w20a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w20a

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

## Usage

Install from npm or pnpm:

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

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

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

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w20a/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-20w20b
Description: Typescript definitions for Minecraft 20w20b (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w20b

Typescript definitions for Minecraft 20w20b (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w20b
# or
pnpm add @minecraft-types/yarn-20w20b
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w20b"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w20b/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-20w21a
Description: Typescript definitions for Minecraft 20w21a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w21a

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

## Usage

Install from npm or pnpm:

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

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

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

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w21a/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-20w22a
Description: Typescript definitions for Minecraft 20w22a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w22a

Typescript definitions for Minecraft 20w22a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w22a
# or
pnpm add @minecraft-types/yarn-20w22a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w22a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w22a/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-20w27a
Description: Typescript definitions for Minecraft 20w27a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w27a

Typescript definitions for Minecraft 20w27a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w27a
# or
pnpm add @minecraft-types/yarn-20w27a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w27a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w27a/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-20w28a
Description: Typescript definitions for Minecraft 20w28a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w28a

Typescript definitions for Minecraft 20w28a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w28a
# or
pnpm add @minecraft-types/yarn-20w28a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w28a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w28a/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-20w29a
Description: Typescript definitions for Minecraft 20w29a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w29a

Typescript definitions for Minecraft 20w29a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w29a
# or
pnpm add @minecraft-types/yarn-20w29a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w29a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w29a/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-20w30a
Description: Typescript definitions for Minecraft 20w30a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w30a

Typescript definitions for Minecraft 20w30a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w30a
# or
pnpm add @minecraft-types/yarn-20w30a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w30a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w30a/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-20w45a
Description: Typescript definitions for Minecraft 20w45a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w45a

Typescript definitions for Minecraft 20w45a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w45a
# or
pnpm add @minecraft-types/yarn-20w45a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w45a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w45a/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-20w46a
Description: Typescript definitions for Minecraft 20w46a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w46a

Typescript definitions for Minecraft 20w46a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w46a
# or
pnpm add @minecraft-types/yarn-20w46a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w46a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w46a/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-20w48a
Description: Typescript definitions for Minecraft 20w48a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w48a

Typescript definitions for Minecraft 20w48a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w48a
# or
pnpm add @minecraft-types/yarn-20w48a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w48a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w48a/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-20w49a
Description: Typescript definitions for Minecraft 20w49a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w49a

Typescript definitions for Minecraft 20w49a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w49a
# or
pnpm add @minecraft-types/yarn-20w49a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w49a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w49a/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-20w51a
Description: Typescript definitions for Minecraft 20w51a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-20w51a

Typescript definitions for Minecraft 20w51a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-20w51a
# or
pnpm add @minecraft-types/yarn-20w51a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w51a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-20w51a/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-21w03a
Description: Typescript definitions for Minecraft 21w03a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-21w03a

Typescript definitions for Minecraft 21w03a (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-21w03a
# or
pnpm add @minecraft-types/yarn-21w03a
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-21w03a"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-21w03a/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-21w05a
Description: Typescript definitions for Minecraft 21w05a (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-21w05a

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

## Usage

Install from npm or pnpm:

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

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

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

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-21w05a/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-21w05b
Description: Typescript definitions for Minecraft 21w05b (Fabric/Yarn mappings), all known builds.
Author: East_Arctica
Latest version: 1.0.3

# @minecraft-types/yarn-21w05b

Typescript definitions for Minecraft 21w05b (Fabric/Yarn mappings), all known builds.

## Usage

Install from npm or pnpm:

```bash
npm install @minecraft-types/yarn-21w05b
# or
pnpm add @minecraft-types/yarn-21w05b
```

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

```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-21w05b"
    ]
  }
}
```

If you require a specific yarn build number instead of the default (latest) build, specify it like this:
```json
{
  "compilerOptions": {
    "types": [
      "@minecraft-types/yarn-21w05b/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