@lzimul/minecraft-mcp 0.0.0-stage → 1.0.0

package/build/data/version.js

@@ -0,0 +1 @@
+export const MINECRAFT_DATA_VERSION = '26.1';

package/build/enums/bounding-box.enum.js

@@ -0,0 +1,5 @@
+export var EBoundingBox;
+(function (EBoundingBox) {
+    EBoundingBox["Empty"] = "empty";
+    EBoundingBox["Block"] = "block";
+})(EBoundingBox || (EBoundingBox = {}));

package/build/enums/dimension-type.enum.js

@@ -0,0 +1,6 @@
+export var EDimensionType;
+(function (EDimensionType) {
+    EDimensionType["Overworld"] = "overworld";
+    EDimensionType["TheNether"] = "the_nether";
+    EDimensionType["TheEnd"] = "the_end";
+})(EDimensionType || (EDimensionType = {}));

package/build/enums/icon-theme.enum.js

@@ -0,0 +1,5 @@
+export var EIconTheme;
+(function (EIconTheme) {
+    EIconTheme["Light"] = "light";
+    EIconTheme["Dark"] = "dark";
+})(EIconTheme || (EIconTheme = {}));

package/build/index.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { serveStdio } from '@modelcontextprotocol/server/stdio';
+import { createServer } from './app/server.js';
+void serveStdio(createServer);

package/build/interfaces/block.interface.js

@@ -0,0 +1 @@
+export {};

package/build/interfaces/data-entry.interface.js

@@ -0,0 +1 @@
+export {};

package/build/interfaces/dimension.interface.js

@@ -0,0 +1 @@
+export {};

package/build/interfaces/item.interface.js

@@ -0,0 +1 @@
+export {};

package/build/interfaces/placed-block.interface.js

@@ -0,0 +1 @@
+export {};

package/build/resources/block-resources.js

@@ -0,0 +1,17 @@
+import { MINECRAFT_BLOCKS, MINECRAFT_BLOCK_COUNT } from '../data/blocks.js';
+import { MINECRAFT_DATA_VERSION } from '../data/version.js';
+import { registerDataEntryResources, registerDataIndexResource } from './data-resources.js';
+export function registerBlockResources(server) {
+    registerDataIndexResource(server, {
+        name: 'minecraft/blocks',
+        uri: 'lzimul://minecraft/blocks',
+        title: 'Minecraft Block List',
+        description: `Index of all ${MINECRAFT_BLOCK_COUNT} Minecraft blocks (Java Edition ${MINECRAFT_DATA_VERSION})`,
+        entries: MINECRAFT_BLOCKS
+    });
+    registerDataEntryResources(server, {
+        pathPrefix: 'blocks',
+        category: 'block',
+        entries: MINECRAFT_BLOCKS
+    });
+}

package/build/resources/data-resources.js

@@ -0,0 +1,40 @@
+function lazyJsonText(build) {
+    let cached = '';
+    return () => {
+        if (!cached) {
+            cached = JSON.stringify(build(), null, 2);
+        }
+        return cached;
+    };
+}
+export function registerDataIndexResource(server, config) {
+    const getText = lazyJsonText(() => config.entries.map(entry => ({
+        id: entry.id,
+        key: entry.key,
+        name: entry.name,
+        displayName: entry.displayName
+    })));
+    server.registerResource(config.name, config.uri, {
+        title: config.title,
+        description: config.description,
+        mimeType: 'application/json'
+    }, async (uri) => ({
+        contents: [
+            { uri: uri.href, mimeType: 'application/json', text: getText() }
+        ]
+    }));
+}
+export function registerDataEntryResources(server, config) {
+    for (const entry of config.entries) {
+        const getText = lazyJsonText(() => entry);
+        server.registerResource(`minecraft/${config.pathPrefix}/${entry.name}`, `lzimul://minecraft/${config.pathPrefix}/${entry.name}`, {
+            title: `${entry.displayName} (${entry.key})`,
+            description: `Properties of the Minecraft ${config.category} ${entry.key}`,
+            mimeType: 'application/json'
+        }, async (uri) => ({
+            contents: [
+                { uri: uri.href, mimeType: 'application/json', text: getText() }
+            ]
+        }));
+    }
+}

package/build/resources/dimension-resources.js

@@ -0,0 +1,54 @@
+import { toBlockInfo } from '../schemas/block-schema.js';
+import { getDimension, listDimensions } from '../world/world-state.js';
+function dimensionState(dimension) {
+    const simulated = getDimension(dimension.type);
+    return {
+        key: dimension.key,
+        type: dimension.type,
+        displayName: dimension.displayName,
+        minY: dimension.minY,
+        maxY: dimension.maxY,
+        hasSkylight: dimension.hasSkylight,
+        modifiedBlockCount: simulated.modifiedBlockCount,
+        placedBlocks: simulated.placedBlocks
+            .map(placed => ({
+            x: placed.x,
+            y: placed.y,
+            z: placed.z,
+            block: toBlockInfo(placed.block)
+        }))
+            .sort((a, b) => a.x - b.x || a.y - b.y || a.z - b.z)
+    };
+}
+export function registerDimensionIndexResource(server) {
+    server.registerResource('minecraft/dimensions', 'lzimul://minecraft/dimensions', {
+        title: 'Minecraft Dimension List',
+        description: 'Index of the simulated Minecraft dimensions',
+        mimeType: 'application/json'
+    }, async (uri) => ({
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: 'application/json',
+                text: JSON.stringify(listDimensions().map(dimensionState), null, 2)
+            }
+        ]
+    }));
+}
+export function registerDimensionResources(server) {
+    for (const dimension of listDimensions()) {
+        server.registerResource(`minecraft/dimensions/${dimension.type}`, `lzimul://minecraft/dimensions/${dimension.type}`, {
+            title: `${dimension.displayName} (${dimension.key})`,
+            description: `Simulated state of the ${dimension.displayName} dimension`,
+            mimeType: 'application/json'
+        }, async (uri) => ({
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(dimensionState(dimension), null, 2)
+                }
+            ]
+        }));
+    }
+}

package/build/resources/index.js

@@ -0,0 +1,9 @@
+import { registerBlockResources } from './block-resources.js';
+import { registerDimensionIndexResource, registerDimensionResources } from './dimension-resources.js';
+import { registerItemResources } from './item-resources.js';
+export function registerResources(server) {
+    registerBlockResources(server);
+    registerItemResources(server);
+    registerDimensionIndexResource(server);
+    registerDimensionResources(server);
+}

package/build/resources/item-resources.js

@@ -0,0 +1,17 @@
+import { MINECRAFT_ITEMS, MINECRAFT_ITEM_COUNT } from '../data/items.js';
+import { MINECRAFT_DATA_VERSION } from '../data/version.js';
+import { registerDataEntryResources, registerDataIndexResource } from './data-resources.js';
+export function registerItemResources(server) {
+    registerDataIndexResource(server, {
+        name: 'minecraft/items',
+        uri: 'lzimul://minecraft/items',
+        title: 'Minecraft Item List',
+        description: `Index of all ${MINECRAFT_ITEM_COUNT} Minecraft items (Java Edition ${MINECRAFT_DATA_VERSION})`,
+        entries: MINECRAFT_ITEMS
+    });
+    registerDataEntryResources(server, {
+        pathPrefix: 'items',
+        category: 'item',
+        entries: MINECRAFT_ITEMS
+    });
+}

package/build/schemas/block-schema.js

@@ -0,0 +1,27 @@
+import * as z from 'zod/v4';
+export const blockInfoSchema = z.object({
+    key: z.string(),
+    name: z.string(),
+    displayName: z.string(),
+    hardness: z.number(),
+    resistance: z.number(),
+    diggable: z.boolean(),
+    transparent: z.boolean(),
+    emitLight: z.number(),
+    filterLight: z.number(),
+    boundingBox: z.string()
+});
+export function toBlockInfo(block) {
+    return {
+        key: block.key,
+        name: block.name,
+        displayName: block.displayName,
+        hardness: block.hardness,
+        resistance: block.resistance,
+        diggable: block.diggable,
+        transparent: block.transparent,
+        emitLight: block.emitLight,
+        filterLight: block.filterLight,
+        boundingBox: block.boundingBox
+    };
+}

package/build/schemas/coordinate-schema.js

@@ -0,0 +1,12 @@
+import * as z from 'zod/v4';
+import { WORLD_LIMITS } from '../config/world-limits.js';
+export const horizontalCoordinate = z
+    .number()
+    .int()
+    .min(WORLD_LIMITS.minHorizontal)
+    .max(WORLD_LIMITS.maxHorizontal);
+export const verticalCoordinate = z
+    .number()
+    .int()
+    .min(WORLD_LIMITS.minVertical)
+    .max(WORLD_LIMITS.maxVertical);

package/build/schemas/dimension-schema.js

@@ -0,0 +1,6 @@
+import * as z from 'zod/v4';
+import { EDimensionType } from '../enums/dimension-type.enum.js';
+export const dimensionSchema = z
+    .enum(EDimensionType)
+    .default(EDimensionType.Overworld);
+export const dimensionTypeSchema = z.enum(EDimensionType);

package/build/schemas/item-schema.js

@@ -0,0 +1,28 @@
+import * as z from 'zod/v4';
+export const itemInfoSchema = z.object({
+    key: z.string(),
+    name: z.string(),
+    displayName: z.string(),
+    stackSize: z.number(),
+    maxDurability: z.number().optional(),
+    enchantCategories: z.array(z.string()).optional(),
+    repairWith: z.array(z.string()).optional()
+});
+export function toItemInfo(item) {
+    const info = {
+        key: item.key,
+        name: item.name,
+        displayName: item.displayName,
+        stackSize: item.stackSize
+    };
+    if (item.maxDurability) {
+        info.maxDurability = item.maxDurability;
+    }
+    if (item.enchantCategories) {
+        info.enchantCategories = [...item.enchantCategories];
+    }
+    if (item.repairWith) {
+        info.repairWith = [...item.repairWith];
+    }
+    return info;
+}

package/build/tools/block-tools.js

@@ -0,0 +1,108 @@
+import * as z from 'zod/v4';
+import { getBlockByName } from '../data/blocks.js';
+import { blockInfoSchema, toBlockInfo } from '../schemas/block-schema.js';
+import { horizontalCoordinate, verticalCoordinate } from '../schemas/coordinate-schema.js';
+import { dimensionSchema } from '../schemas/dimension-schema.js';
+import { getDimension } from '../world/world-state.js';
+import { toolError } from './result.js';
+function rangeError(info, x, y, z) {
+    return toolError(`Coordinates (${x}, ${y}, ${z}) are out of range in ${info.displayName} (Y: ${info.minY} to ${info.maxY - 1}).`);
+}
+export function registerBlockTools(server) {
+    server.registerTool('getBlock', {
+        title: 'Get Block',
+        description: 'Get the block at the given coordinates in the given dimension, including its properties (name, hardness, light level, etc.). Each dimension has its own world state; unmodified coordinates return air (minecraft:air).',
+        inputSchema: z.object({
+            x: horizontalCoordinate.describe('X coordinate (-30000000 to 30000000)'),
+            y: verticalCoordinate.describe('Y coordinate, within the dimension height range'),
+            z: horizontalCoordinate.describe('Z coordinate (-30000000 to 30000000)'),
+            dimension: dimensionSchema.describe('Dimension: "overworld" (default), "the_nether" or "the_end"')
+        }),
+        outputSchema: z.object({
+            x: z.number(),
+            y: z.number(),
+            z: z.number(),
+            dimension: z.string(),
+            block: blockInfoSchema
+        }),
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ x, y, z, dimension: dimensionType }) => {
+        const dimension = getDimension(dimensionType);
+        if (!dimension.contains(x, y, z)) {
+            return rangeError(dimension.info, x, y, z);
+        }
+        const block = dimension.getBlock(x, y, z);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Block at (${x}, ${y}, ${z}) in ${dimension.info.displayName} is ${block.displayName} (${block.key})`
+                }
+            ],
+            structuredContent: {
+                x,
+                y,
+                z,
+                dimension: dimension.info.key,
+                block: toBlockInfo(block)
+            }
+        };
+    });
+    server.registerTool('setBlock', {
+        title: 'Set Block',
+        description: 'Place a block at the given coordinates in the given dimension and return the replaced block. Each dimension has its own world state. blockType is a block id such as "minecraft:stone" or "stone"; see the resource lzimul://minecraft/blocks for the full list.',
+        inputSchema: z.object({
+            x: horizontalCoordinate.describe('X coordinate (-30000000 to 30000000)'),
+            y: verticalCoordinate.describe('Y coordinate, within the dimension height range'),
+            z: horizontalCoordinate.describe('Z coordinate (-30000000 to 30000000)'),
+            blockType: z
+                .string()
+                .min(1)
+                .describe('Block id, such as "minecraft:stone"'),
+            dimension: dimensionSchema.describe('Dimension: "overworld" (default), "the_nether" or "the_end"')
+        }),
+        outputSchema: z.object({
+            x: z.number(),
+            y: z.number(),
+            z: z.number(),
+            dimension: z.string(),
+            block: blockInfoSchema,
+            previous: blockInfoSchema
+        }),
+        annotations: {
+            destructiveHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ x, y, z, blockType, dimension: dimensionType }) => {
+        const dimension = getDimension(dimensionType);
+        if (!dimension.contains(x, y, z)) {
+            return rangeError(dimension.info, x, y, z);
+        }
+        const block = getBlockByName(blockType);
+        if (!block) {
+            return toolError(`Unknown block "${blockType}". Use a block id such as "minecraft:stone"; see the resource lzimul://minecraft/blocks for the full list.`);
+        }
+        const previous = dimension.setBlock(x, y, z, block);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Block set at (${x}, ${y}, ${z}) in ${dimension.info.displayName}: ${previous.displayName} (${previous.key}) -> ${block.displayName} (${block.key})`
+                }
+            ],
+            structuredContent: {
+                x,
+                y,
+                z,
+                dimension: dimension.info.key,
+                block: toBlockInfo(block),
+                previous: toBlockInfo(previous)
+            }
+        };
+    });
+}

package/build/tools/index.js

@@ -0,0 +1,6 @@
+import { registerBlockTools } from './block-tools.js';
+import { registerItemTools } from './item-tools.js';
+export function registerTools(server) {
+    registerBlockTools(server);
+    registerItemTools(server);
+}

package/build/tools/item-tools.js

@@ -0,0 +1,43 @@
+import * as z from 'zod/v4';
+import { getItemByName } from '../data/items.js';
+import { itemInfoSchema, toItemInfo } from '../schemas/item-schema.js';
+import { toolError } from './result.js';
+export function registerItemTools(server) {
+    server.registerTool('getItem', {
+        title: 'Get Item',
+        description: 'Get the properties of a Minecraft item by id (stack size, durability, enchantment categories, etc.). See the resource lzimul://minecraft/items for the full list.',
+        inputSchema: z.object({
+            item: z
+                .string()
+                .min(1)
+                .describe('Item id, such as "minecraft:diamond_sword" or "diamond_sword"')
+        }),
+        outputSchema: z.object({
+            item: itemInfoSchema
+        }),
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: false
+        }
+    }, async ({ item: itemId }) => {
+        const item = getItemByName(itemId);
+        if (!item) {
+            return toolError(`Unknown item "${itemId}". Use an item id such as "minecraft:diamond_sword"; see the resource lzimul://minecraft/items for the full list.`);
+        }
+        const durability = item.maxDurability
+            ? `, durability ${item.maxDurability}`
+            : '';
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `${item.displayName} (${item.key}): stack size ${item.stackSize}${durability}`
+                }
+            ],
+            structuredContent: {
+                item: toItemInfo(item)
+            }
+        };
+    });
+}

package/build/tools/result.js

@@ -0,0 +1,11 @@
+export function toolText(text) {
+    return {
+        content: [{ type: 'text', text }]
+    };
+}
+export function toolError(message) {
+    return {
+        isError: true,
+        content: [{ type: 'text', text: message }]
+    };
+}

package/build/world/simulated-dimension.js

@@ -0,0 +1,36 @@
+import { WORLD_LIMITS } from '../config/world-limits.js';
+import { getBlockByName, MINECRAFT_BLOCKS } from '../data/blocks.js';
+const AIR = getBlockByName('air') ?? MINECRAFT_BLOCKS[0];
+function coordinateKey(x, y, z) {
+    return `${x},${y},${z}`;
+}
+export class SimulatedDimension {
+    info;
+    blocks = new Map();
+    constructor(info) {
+        this.info = info;
+    }
+    get modifiedBlockCount() {
+        return this.blocks.size;
+    }
+    get placedBlocks() {
+        return [...this.blocks.values()];
+    }
+    contains(x, y, z) {
+        return (y >= this.info.minY &&
+            y < this.info.maxY &&
+            x >= WORLD_LIMITS.minHorizontal &&
+            x <= WORLD_LIMITS.maxHorizontal &&
+            z >= WORLD_LIMITS.minHorizontal &&
+            z <= WORLD_LIMITS.maxHorizontal);
+    }
+    getBlock(x, y, z) {
+        return this.blocks.get(coordinateKey(x, y, z))?.block ?? AIR;
+    }
+    setBlock(x, y, z, block) {
+        const key = coordinateKey(x, y, z);
+        const previous = this.blocks.get(key)?.block ?? AIR;
+        this.blocks.set(key, { x, y, z, block });
+        return previous;
+    }
+}

package/build/world/world-state.js

@@ -0,0 +1,16 @@
+import { DIMENSIONS } from '../config/dimensions.js';
+import { SimulatedDimension } from './simulated-dimension.js';
+const dimensions = new Map(DIMENSIONS.map(dimension => [
+    dimension.type,
+    new SimulatedDimension(dimension)
+]));
+export function getDimension(type) {
+    const dimension = dimensions.get(type);
+    if (!dimension) {
+        throw new Error(`Unknown dimension: ${type}`);
+    }
+    return dimension;
+}
+export function listDimensions() {
+    return DIMENSIONS;
+}

package/lib/app/server.d.ts

@@ -0,0 +1,3 @@
+import { McpServer } from '@modelcontextprotocol/server';
+export declare function createServer(): McpServer;
+//# sourceMappingURL=server.d.ts.map

package/lib/app/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/app/server.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAMzD,wBAAgB,YAAY,IAAI,SAAS,CAKxC"}

package/lib/config/dimensions.d.ts

@@ -0,0 +1,3 @@
+import type { IDimension } from '../interfaces/dimension.interface.js';
+export declare const DIMENSIONS: readonly IDimension[];
+//# sourceMappingURL=dimensions.d.ts.map

package/lib/config/dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimensions.d.ts","sourceRoot":"","sources":["../../src/config/dimensions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sCAAsC,CAAC;AAEvE,eAAO,MAAM,UAAU,EAAE,SAAS,UAAU,EAyB3C,CAAC"}

package/lib/config/server-info.d.ts

@@ -0,0 +1,15 @@
+import { EIconTheme } from '../enums/icon-theme.enum.js';
+export declare const SERVER_INFO: {
+  name: string;
+  title: string;
+  description: string;
+  version: string;
+  websiteUrl: string;
+  icons: {
+    src: string;
+    mimeType: string;
+    sizes: string[];
+    theme: EIconTheme;
+  }[];
+};
+//# sourceMappingURL=server-info.d.ts.map

package/lib/config/server-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server-info.d.ts","sourceRoot":"","sources":["../../src/config/server-info.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAEzD,eAAO,MAAM,WAAW;;;;;;;;;;;;CAoBvB,CAAC"}

package/lib/config/world-limits.d.ts

@@ -0,0 +1,7 @@
+export declare const WORLD_LIMITS: {
+  readonly minHorizontal: -30000000;
+  readonly maxHorizontal: 30000000;
+  readonly minVertical: -64;
+  readonly maxVertical: 320;
+};
+//# sourceMappingURL=world-limits.d.ts.map

package/lib/config/world-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"world-limits.d.ts","sourceRoot":"","sources":["../../src/config/world-limits.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;;CAKf,CAAC"}

package/lib/data/blocks.d.ts

@@ -0,0 +1,5 @@
+import type { IBlock } from '../interfaces/block.interface.js';
+export declare const MINECRAFT_BLOCKS: readonly IBlock[];
+export declare const MINECRAFT_BLOCK_COUNT: number;
+export declare function getBlockByName(name: string): IBlock | undefined;
+//# sourceMappingURL=blocks.d.ts.map

package/lib/data/blocks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blocks.d.ts","sourceRoot":"","sources":["../../src/data/blocks.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAC;AAE/D,eAAO,MAAM,gBAAgB,EAAE,SAAS,MAAM,EAiniB7C,CAAC;AAEF,eAAO,MAAM,qBAAqB,QAA0B,CAAC;AAQ7D,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAE/D"}

package/lib/data/items.d.ts

@@ -0,0 +1,5 @@
+import type { IItem } from '../interfaces/item.interface.js';
+export declare const MINECRAFT_ITEMS: readonly IItem[];
+export declare const MINECRAFT_ITEM_COUNT: number;
+export declare function getItemByName(name: string): IItem | undefined;
+//# sourceMappingURL=items.d.ts.map

package/lib/data/items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"items.d.ts","sourceRoot":"","sources":["../../src/data/items.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,iCAAiC,CAAC;AAE7D,eAAO,MAAM,eAAe,EAAE,SAAS,KAAK,EAg7V3C,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAyB,CAAC;AAQ3D,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,KAAK,GAAG,SAAS,CAE7D"}

package/lib/data/version.d.ts

@@ -0,0 +1,2 @@
+export declare const MINECRAFT_DATA_VERSION = '26.1';
+//# sourceMappingURL=version.d.ts.map

package/lib/data/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/data/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,sBAAsB,SAAS,CAAC"}

package/lib/enums/bounding-box.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum EBoundingBox {
+  Empty = 'empty',
+  Block = 'block'
+}
+//# sourceMappingURL=bounding-box.enum.d.ts.map

package/lib/enums/bounding-box.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bounding-box.enum.d.ts","sourceRoot":"","sources":["../../src/enums/bounding-box.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY;IACtB,KAAK,UAAU;IACf,KAAK,UAAU;CAChB"}

package/lib/enums/dimension-type.enum.d.ts

@@ -0,0 +1,6 @@
+export declare enum EDimensionType {
+  Overworld = 'overworld',
+  TheNether = 'the_nether',
+  TheEnd = 'the_end'
+}
+//# sourceMappingURL=dimension-type.enum.d.ts.map

package/lib/enums/dimension-type.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dimension-type.enum.d.ts","sourceRoot":"","sources":["../../src/enums/dimension-type.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,cAAc;IACxB,SAAS,cAAc;IACvB,SAAS,eAAe;IACxB,MAAM,YAAY;CACnB"}

package/lib/enums/icon-theme.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum EIconTheme {
+  Light = 'light',
+  Dark = 'dark'
+}
+//# sourceMappingURL=icon-theme.enum.d.ts.map

package/lib/enums/icon-theme.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon-theme.enum.d.ts","sourceRoot":"","sources":["../../src/enums/icon-theme.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,UAAU;IACpB,KAAK,UAAU;IACf,IAAI,SAAS;CACd"}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/lib/interfaces/block.interface.d.ts

@@ -0,0 +1,14 @@
+import { EBoundingBox } from '../enums/bounding-box.enum.js';
+import type { IDataEntry } from './data-entry.interface.js';
+export interface IBlock extends IDataEntry {
+  readonly hardness: number;
+  readonly resistance: number;
+  readonly stackSize: number;
+  readonly diggable: boolean;
+  readonly material: string;
+  readonly transparent: boolean;
+  readonly emitLight: number;
+  readonly filterLight: number;
+  readonly boundingBox: EBoundingBox;
+}
+//# sourceMappingURL=block.interface.d.ts.map

package/lib/interfaces/block.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.interface.d.ts","sourceRoot":"","sources":["../../src/interfaces/block.interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAE7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAE5D,MAAM,WAAW,MAAO,SAAQ,UAAU;IACxC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;IAC9B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,YAAY,CAAC;CACpC"}

package/lib/interfaces/data-entry.interface.d.ts

@@ -0,0 +1,7 @@
+export interface IDataEntry {
+  readonly id: number;
+  readonly key: string;
+  readonly name: string;
+  readonly displayName: string;
+}
+//# sourceMappingURL=data-entry.interface.d.ts.map