mcbe-leveldb 1.0.0 → 1.1.0

package/nbtSchemas.js

@@ -2290,9 +2290,9 @@ however when the corresponding block in the block layer is broken, this block ge
             },
             $fragment: false,
         },
-        VILLAGE_DWELLERS: {
-            id: "VILLAGE_DWELLERS",
-            title: "The VILLAGE_DWELLERS schema.",
+        VillageDwellers: {
+            id: "VillageDwellers",
+            title: "The VillageDwellers schema.",
             description: "The village dwellers data.",
             type: "compound",
             properties: {
@@ -2335,9 +2335,9 @@ however when the corresponding block in the block layer is broken, this block ge
             },
             $fragment: false,
         },
-        VILLAGE_INFO: {
-            id: "VILLAGE_INFO",
-            title: "The VILLAGE_INFO schema.",
+        VillageInfo: {
+            id: "VillageInfo",
+            title: "The VillageInfo schema.",
             description: "The village info data.",
             type: "compound",
             properties: {
@@ -2401,9 +2401,9 @@ however when the corresponding block in the block layer is broken, this block ge
             },
             $fragment: false,
         },
-        VILLAGE_PLAYERS: {
-            id: "VILLAGE_PLAYERS",
-            title: "The VILLAGE_PLAYERS schema.",
+        VillagePlayers: {
+            id: "VillagePlayers",
+            title: "The VillagePlayers schema.",
             description: "The village players data.",
             type: "compound",
             properties: {
@@ -2413,9 +2413,9 @@ however when the corresponding block in the block layer is broken, this block ge
             },
             $fragment: false,
         },
-        VILLAGE_POI: {
-            id: "VILLAGE_POI",
-            title: "The VILLAGE_POI schema.",
+        VillagePOI: {
+            id: "VillagePOI",
+            title: "The VillagePOI schema.",
             description: "The village POIs data.",
             type: "compound",
             properties: {
@@ -7614,6 +7614,66 @@ however when the corresponding block in the block layer is broken, this block ge
             $fragment: false,
         },
         //#endregion
+        //#region Custom NBT Schemas
+        SubChunkPrefix: {
+            id: "SubChunkPrefix",
+            title: "The SubChunkPrefix schema.",
+            description: "A custom schema for the NBT structure used by the custom parser and serializer for the SubChunkPrefix content type.",
+            type: "compound",
+            required: ["version", "layerCount", "layers"],
+            properties: {
+                version: {
+                    type: "byte",
+                    enum: [
+                        {
+                            type: "byte",
+                            value: 0x08,
+                        },
+                        {
+                            type: "byte",
+                            value: 0x09,
+                        },
+                    ],
+                },
+                layerCount: {
+                    type: "byte",
+                },
+                layers: {
+                    type: "list",
+                    items: {
+                        $ref: "SubChunkPrefixLayer",
+                    },
+                },
+                subChunkIndex: {
+                    type: "byte",
+                },
+            },
+            $fragment: false,
+        },
+        SubChunkPrefixLayer: {
+            id: "SubChunkPrefixLayer",
+            title: "The SubChunkPrefixLayer schema.",
+            description: "A custom schema for the NBT structure used by the custom parser and serializer for the SubChunkPrefix content type.",
+            type: "compound",
+            required: ["storageVersion", "palette", "block_indices"],
+            properties: {
+                storageVersion: {
+                    type: "byte",
+                },
+                palette: {
+                    type: "compound",
+                    additionalProperties: { $ref: "Block" },
+                },
+                block_indices: {
+                    type: "list",
+                    items: {
+                        type: "int",
+                    },
+                },
+            },
+            $fragment: true,
+        },
+        //#endregion
     }, {
         /**
          * This is an alias of {@link nbtSchemas.PlayerClient}, this only exists because it is what it is called on the Minecraft Wiki, so it is here for the Minecraft Wiki data to schema converter.
@@ -7624,6 +7684,12 @@ however when the corresponding block in the block layer is broken, this block ge
             key: "PlayerClient",
             description: "The players data.",
         },
+        /**
+         * This is an alias of {@link nbtSchemas.Entity_Player}.
+         */
+        Player: {
+            key: "Entity_Player",
+        },
         /**
          * This is an alias of {@link nbtSchemas.TickingArea}, this only exists because it is what it is called on the Minecraft Wiki, so it is here for the Minecraft Wiki data to schema converter.
          *
@@ -7632,6 +7698,38 @@ however when the corresponding block in the block layer is broken, this block ge
         Tickingarea: {
             key: "TickingArea",
         },
+        /**
+         * This is an alias of {@link nbtSchemas.VillageDwellers}, this only exists because it is what it is called on the Minecraft Wiki, so it is here for the Minecraft Wiki data to schema converter.
+         *
+         * @deprecated Use {@link nbtSchemas.VillageDwellers} instead.
+         */
+        VILLAGE_DWELLERS: {
+            key: "VillageDwellers",
+        },
+        /**
+         * This is an alias of {@link nbtSchemas.VillageInfo}, this only exists because it is what it is called on the Minecraft Wiki, so it is here for the Minecraft Wiki data to schema converter.
+         *
+         * @deprecated Use {@link nbtSchemas.VillageInfo} instead.
+         */
+        VILLAGE_INFO: {
+            key: "VillageInfo",
+        },
+        /**
+         * This is an alias of {@link nbtSchemas.VillagePlayers}, this only exists because it is what it is called on the Minecraft Wiki, so it is here for the Minecraft Wiki data to schema converter.
+         *
+         * @deprecated Use {@link nbtSchemas.VillagePlayers} instead.
+         */
+        VILLAGE_PLAYERS: {
+            key: "VillagePlayers",
+        },
+        /**
+         * This is an alias of {@link nbtSchemas.VillagePOI}, this only exists because it is what it is called on the Minecraft Wiki, so it is here for the Minecraft Wiki data to schema converter.
+         *
+         * @deprecated Use {@link nbtSchemas.VillagePOI} instead.
+         */
+        VILLAGE_POI: {
+            key: "VillagePOI",
+        },
     });
     NBTSchemas.GenericPrismarineJSONNBTSchema = {
         $schema: "https://json-schema.org/draft/2020-12/schema",
@@ -8122,7 +8220,7 @@ however when the corresponding block in the block layer is broken, this block ge
                         const defVal = formatValue(schema.default);
                         // Put on new line if contains non-alphanumeric characters
                         if (/[^a-zA-Z0-9_.=+-]/.test(defVal) && !/^"[a-zA-Z0-9_.=+-\s]+"$/.test(defVal)) {
-                            parts.push(`@default\n${indent}${defVal}`);
+                            parts.push(`@default\n${defVal}`);
                         }
                         else {
                             parts.push(`@default ${defVal}`);
@@ -8133,7 +8231,7 @@ however when the corresponding block in the block layer is broken, this block ge
                         for (const ex of schema.examples) {
                             const exVal = formatValue(ex);
                             if (/[^a-zA-Z0-9_]/.test(exVal)) {
-                                parts.push(`@example\n${indent}${exVal}`);
+                                parts.push(`@example\n${exVal}`);
                             }
                             else {
                                 parts.push(`@example ${exVal}`);
@@ -8144,7 +8242,7 @@ however when the corresponding block in the block layer is broken, this block ge
                     if (schema.enum && Array.isArray(schema.enum)) {
                         parts.push(`@enum ${formatEnum(schema.enum)}`);
                         if (schema.enumDescriptions && Array.isArray(schema.enumDescriptions)) {
-                            parts.push(`@enumDescriptions\n${indent}${schema.enumDescriptions
+                            parts.push(`@enumDescriptions\n${schema.enumDescriptions
                                 .map((d, i) => `- ${schema.enum[i]?.value !== undefined ? `\`${schema.enum[i]?.value}\`` : `UNKNOWN_ENUM_MEMBER_${i}`}: ${d}`)
                                 .join("\n")}`);
                         }
@@ -8157,7 +8255,7 @@ however when the corresponding block in the block layer is broken, this block ge
                         .map((l) => `${indent} * ${l}`);
                     return `${indent}/**\n${lines.join("\n")}\n${indent} */\n`;
                 }
-                function refToType(ref, indent, opts = {}, ctx = { helperTypes: [], helperCounter: 0 }) {
+                function refToType(ref, indent, opts = {}, ctx = { helperTypes: [], helperCounter: 0 }, additionalInformation = {}) {
                     const refLookup = opts.refLookup ?? NBTSchemas.nbtSchemas;
                     const resolvedRef = (typeof ref === "boolean"
                         ? ref
@@ -8201,7 +8299,7 @@ however when the corresponding block in the block layer is broken, this block ge
                         if (resolvedRef.length === 0)
                             return { type: "never", value: "never" };
                         // tuple-style list -> union of each item
-                        const children = resolvedRef.map((r) => refToType(r, indent, opts, ctx));
+                        const children = resolvedRef.map((r) => refToType(r, indent, opts, ctx, { ...additionalInformation, isListChild: true }));
                         const allSameType = children.every((c) => c.type === children[0].type);
                         if (allSameType) {
                             // collapse into single type wrapping array of values
@@ -8228,9 +8326,9 @@ however when the corresponding block in the block layer is broken, this block ge
                         }
                     }
                     // single schema
-                    return schemaToBuiltType(resolvedRef, indent, opts, ctx);
+                    return schemaToBuiltType(resolvedRef, indent, opts, ctx, additionalInformation);
                 }
-                function schemaToBuiltType(schema, indent, opts, ctx) {
+                function schemaToBuiltType(schema, indent, opts, ctx, additionalInformation = {}) {
                     const refLookup = opts.refLookup ?? NBTSchemas.nbtSchemas;
                     const st = schema.type;
                     const mainSchemaRefName = schema.$ref
@@ -8245,14 +8343,15 @@ however when the corresponding block in the block layer is broken, this block ge
                     let allOfRefTypes = opts.inlineRefs ?? false
                         ? undefined
                         : typeof schema === "object" && schema.$ref !== undefined && mainSchemaRefName !== undefined /*  && schema.$ref in refLookup */
-                            ? [mainSchemaRefName]
+                            ? [mainSchemaRefName + (additionalInformation.isListChild ? '["value"]' : "")]
                             : undefined;
                     if (!(opts.inlineRefs ?? false) && schema.allOf !== undefined) {
                         const refAllOfs = schema.allOf.filter((ref) => typeof ref === "object" && !!ref.$ref);
                         if (refAllOfs.length > 0) {
                             allOfRefTypes ??= [];
                             for (const refAllOf of refAllOfs) {
-                                allOfRefTypes.push(resolveSchemaRefName(refAllOf.$ref, !(opts.inlineRefs ?? false), opts));
+                                allOfRefTypes.push(resolveSchemaRefName(refAllOf.$ref, !(opts.inlineRefs ?? false), opts) +
+                                    (additionalInformation.isListChild ? '["value"]' : ""));
                             }
                         }
                     }
@@ -8262,7 +8361,8 @@ however when the corresponding block in the block layer is broken, this block ge
                         if (refOneOfs.length > 0) {
                             oneOfRefTypes ??= [];
                             for (const refOneOf of refOneOfs) {
-                                oneOfRefTypes.push(resolveSchemaRefName(refOneOf.$ref, !(opts.inlineRefs ?? false), opts));
+                                oneOfRefTypes.push(resolveSchemaRefName(refOneOf.$ref, !(opts.inlineRefs ?? false), opts) +
+                                    (additionalInformation.isListChild ? '["value"]' : ""));
                             }
                         }
                     }
@@ -8298,21 +8398,28 @@ however when the corresponding block in the block layer is broken, this block ge
                         if (resolvedSchema.properties) {
                             const compoundType = buildBuiltTypeForTag("compound", resolvedSchema, indent, opts, ctx);
                             return {
-                                type: "compound",
+                                type: '"compound"',
                                 value: opts.inlineRefs ?? false
-                                    ? `(${compoundType.value})${inlineRefTypes.allOf ? ` & ${inlineRefTypes.allOf.join(" & ")}` : ""}${inlineRefTypes.oneOf ? ` & (${inlineRefTypes.oneOf.join(" | ")})` : ""}`
-                                    : `(${compoundType.value})${allOfRefTypes ? ` & ${allOfRefTypes.join(" & ")}` : ""}${oneOfRefTypes ? ` & (${oneOfRefTypes.join(" | ")})` : ""}`,
+                                    ? `${(allOfRefTypes || oneOfRefTypes) && /^\{\s*\}$/.test(compoundType.value) ? "" : `(${compoundType.value})`}${inlineRefTypes.allOf ? ` & ${inlineRefTypes.allOf.join(" & ")}` : ""}${inlineRefTypes.oneOf ? ` & (${inlineRefTypes.oneOf.join(" | ")})` : ""}`
+                                    : `${(allOfRefTypes || oneOfRefTypes) && /^\{\s*\}$/.test(compoundType.value) ? "" : `(${compoundType.value})`}${allOfRefTypes ? ` & ${allOfRefTypes.join(" & ")}` : ""}${oneOfRefTypes ? ` & (${oneOfRefTypes.join(" | ")})` : ""}`.replace(/^ & /, ""),
+                            };
+                        }
+                        if (!(opts.inlineRefs ?? false) && schema.$ref) {
+                            const refType = refLookup[resolveSchemaRefName(schema.$ref, false, opts)]
+                                ?.type;
+                            return {
+                                type: typeof refType === "string" ? `"${refType}"` : "unknown",
+                                value: mainSchemaRefName + (additionalInformation.isListChild ? '["value"]' : ""),
                             };
                         }
-                        // BUG: This is not resolving $ref properties.
                         return { type: "unknown", value: "any" };
                     }
                     const builtType = buildBuiltTypeForTag(st, resolvedSchema, indent, opts, ctx);
                     return {
                         type: builtType.type,
                         value: opts.inlineRefs ?? false
-                            ? `(${builtType.value})${inlineRefTypes.allOf ? ` & ${inlineRefTypes.allOf.join(" & ")}` : ""}${inlineRefTypes.oneOf ? ` & (${inlineRefTypes.oneOf.join(" | ")})` : ""}`
-                            : `(${builtType.value})${allOfRefTypes ? ` & ${allOfRefTypes.join(" & ")}` : ""}${oneOfRefTypes ? ` & (${oneOfRefTypes.join(" | ")})` : ""}`,
+                            ? `${(allOfRefTypes || oneOfRefTypes) && /^\{\s*\}$/.test(builtType.value) ? "" : `(${builtType.value})`}${inlineRefTypes.allOf ? ` & ${inlineRefTypes.allOf.join(" & ")}` : ""}${inlineRefTypes.oneOf ? ` & (${inlineRefTypes.oneOf.join(" | ")})` : ""}`.replace(/^ & /, "")
+                            : `${(allOfRefTypes || oneOfRefTypes) && /^\{\s*\}$/.test(builtType.value) ? "" : `(${builtType.value})`}${allOfRefTypes ? ` & ${allOfRefTypes.join(" & ")}` : ""}${oneOfRefTypes ? ` & (${oneOfRefTypes.join(" | ")})` : ""}`.replace(/^ & /, ""),
                     };
                 }
                 function buildBuiltTypeForTag(tagType, schema, indent, opts, ctx) {
@@ -8387,7 +8494,7 @@ however when the corresponding block in the block layer is broken, this block ge
                         }
                         // homogeneous list
                         if (Array.isArray(items)) {
-                            const child = refToType(items, indent + "  ", opts, ctx);
+                            const child = refToType(items, indent + "    ", opts, ctx);
                             function builtTypeValueToTupleList(value) {
                                 return typeof value === "string"
                                     ? value
@@ -8408,7 +8515,7 @@ however when the corresponding block in the block layer is broken, this block ge
                         }
                         else {
                             // TO-DO: Test this, as it may not work correctly.
-                            const child = refToType(items, indent + "  ", opts, ctx);
+                            const child = refToType(items, indent + "    ", opts, ctx, { isListChild: true });
                             function builtTypeValueToUnionList(value) {
                                 return typeof value === "string"
                                     ? value
@@ -8428,7 +8535,7 @@ however when the corresponding block in the block layer is broken, this block ge
                             const comment = renderComment(childSchema, undefined, indent);
                             const required = parentReq.has(key) || childSchema.required === true;
                             const sep = required ? ":" : "?:";
-                            return comment + `${indent}${JSON.stringify(key)}${sep} ${schemaToType(childSchema, indent + "  ", opts, ctx)};`;
+                            return comment + `${indent}${JSON.stringify(key)}${sep} ${schemaToType(childSchema, indent + "    ", opts, ctx)};`;
                         });
                         const propLinesCount = lines.length;
                         if (schema.patternProperties) {
@@ -8463,7 +8570,7 @@ however when the corresponding block in the block layer is broken, this block ge
                                         keyType = `\`${key.replaceAll("\\d+", "${number}")}\``;
                                         break;
                                 }
-                                found.push([keyType, schemaToType(value, indent + "  ", opts, ctx)]);
+                                found.push([keyType, schemaToType(value, indent + "    ", opts, ctx)]);
                             }
                             for (const key of new Set(found.map(([key]) => key))) {
                                 if (found.filter(([key2]) => key2 === key).length === 1) {
@@ -8483,7 +8590,15 @@ however when the corresponding block in the block layer is broken, this block ge
                                     lines.push(`${propLinesCount > 0 ? `${indent}} & {\n` : ""}${indent}[key: string]: { type: any, value: any };`);
                                 }
                                 else {
-                                    lines.push(`${propLinesCount > 0 ? `${indent}} & {\n` : ""}${indent}[key: string]: ${schemaToType(schema.additionalProperties, indent + "  ", opts, ctx)};`);
+                                    const builtType = schemaToBuiltType(schema.additionalProperties, indent + "    ", opts, ctx);
+                                    if (schema.additionalProperties.$ref) {
+                                        lines.push(`${propLinesCount > 0 ? `${indent}} & {\n` : ""}${indent}[key: string]: ${builtType.value};`);
+                                    }
+                                    else {
+                                        lines.push(`${propLinesCount > 0 ? `${indent}} & {\n` : ""}${indent}[key: string]: ${builtType.value.includes("\n")
+                                            ? `{\n${indent}type: ${builtType.type},\n${indent}value: ${builtType.value}\n${indent}}`
+                                            : `{ type: ${builtType.type}, value: ${builtType.value} }`};`);
+                                    }
                                 }
                             }
                         }
@@ -8561,100 +8676,86 @@ however when the corresponding block in the block layer is broken, this block ge
                  */
                 function schemaToType(schema, indent = "s".repeat(4), opts = {}, ctx = { helperTypes: [], helperCounter: 0 }) {
                     const refLookup = opts.refLookup ?? NBTSchemas.nbtSchemas;
-                    if (schema.$ref !== undefined && schema.$ref in refLookup && typeof refLookup[schema.$ref] === "string") {
-                        return ((Object.keys(schema).length > 1
-                            ? `(${schemaToType(Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "$ref")), indent, opts, ctx)}) & `
-                            : "") + refLookup[schema.$ref]);
+                    const st = schema.type;
+                    const mainSchemaRefName = schema.$ref
+                        ? resolveSchemaRefName(schema.$ref, !(opts.inlineRefs ?? false), opts)
+                        : undefined;
+                    const resolvedSchema = opts.inlineRefs && schema.$ref && mainSchemaRefName && mainSchemaRefName in refLookup
+                        ? {
+                            ...refLookup[mainSchemaRefName],
+                            ...schema,
+                        }
+                        : schema;
+                    let allOfRefTypes = opts.inlineRefs ?? false
+                        ? undefined
+                        : typeof schema === "object" && schema.$ref !== undefined && mainSchemaRefName !== undefined /*  && schema.$ref in refLookup */
+                            ? [mainSchemaRefName]
+                            : undefined;
+                    if (!(opts.inlineRefs ?? false) && schema.allOf !== undefined) {
+                        const refAllOfs = schema.allOf.filter((ref) => typeof ref === "object" && !!ref.$ref);
+                        if (refAllOfs.length > 0) {
+                            allOfRefTypes ??= [];
+                            for (const refAllOf of refAllOfs) {
+                                allOfRefTypes.push(resolveSchemaRefName(refAllOf.$ref, !(opts.inlineRefs ?? false), opts));
+                            }
+                        }
+                    }
+                    let oneOfRefTypes = undefined;
+                    if (!(opts.inlineRefs ?? false) && schema.oneOf !== undefined) {
+                        const refOneOfs = schema.oneOf.filter((ref) => typeof ref === "object" && !!ref.$ref);
+                        if (refOneOfs.length > 0) {
+                            oneOfRefTypes ??= [];
+                            for (const refOneOf of refOneOfs) {
+                                oneOfRefTypes.push(resolveSchemaRefName(refOneOf.$ref, !(opts.inlineRefs ?? false), opts));
+                            }
+                        }
                     }
-                    const resolvedSchema = schema.$ref !== undefined && schema.$ref in refLookup
-                        ? /* opts.inlineRefs ?? false
-                            ? {
-                                  ...(refLookup[schema.$ref as keyof typeof refLookup] as NBTSubSchema),
-                                  //   ...(allOfRefTypes && allOfRefTypes.length > 0
-                                  //       ? allOfRefTypes.reduce(
-                                  //             (a, b): NBTSubSchema => ({
-                                  //                 ...a,
-                                  //                 ...(typeof refLookup[b as keyof typeof refLookup] === "object"
-                                  //                     ? (refLookup[b as keyof typeof refLookup] as Extract<
-                                  //                           (typeof refLookup)[keyof typeof refLookup],
-                                  //                           object
-                                  //                       >)
-                                  //                     : {}),
-                                  //             }),
-                                  //             {}
-                                  //         )
-                                  //       : {}),
-                                  ...Object.fromEntries(Object.entries(schema).filter(([key]): boolean => key !== "$ref")),
-                              }
-                            : */
-                            {
-                                type: refLookup[schema.$ref].type,
-                                ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "$ref")),
+                    const inlineRefTypes = {
+                        allOf: [],
+                        oneOf: [],
+                    };
+                    if (opts.inlineRefs ?? false) {
+                        if (allOfRefTypes)
+                            for (const refType of allOfRefTypes) {
+                                const types = refLookup[refType].type ?? resolvedSchema.type;
+                                if (!types)
+                                    continue;
+                                inlineRefTypes.allOf.push(Array.isArray(types)
+                                    ? types
+                                        .map((t) => buildTypeForTag(t, refLookup[refType], indent, opts, ctx))
+                                        .join("|")
+                                    : buildTypeForTag(types, refLookup[refType], indent, opts, ctx));
                             }
-                        : schema;
-                    // const inlineRefTypes = {
-                    //     allOf: [] as string[],
-                    //     oneOf: [] as string[],
-                    // };
-                    // if (opts.inlineRefs ?? false) {
-                    //     if (allOfRefTypes)
-                    //         for (const refType of allOfRefTypes) {
-                    //             const types = (refLookup[refType as keyof typeof refLookup] as NBTSubSchema).type ?? schema.type;
-                    //             if (!types) continue;
-                    //             inlineRefTypes.allOf.push(
-                    //                 Array.isArray(types)
-                    //                     ? types
-                    //                           .map((t: string): string =>
-                    //                               buildTypeForTag(t, refLookup[refType as keyof typeof refLookup] as NBTSubSchema, indent, opts, ctx)
-                    //                           )
-                    //                           .join("|")
-                    //                     : buildTypeForTag(types, refLookup[refType as keyof typeof refLookup] as NBTSubSchema, indent, opts, ctx)
-                    //             );
-                    //         }
-                    //     if (oneOfRefTypes)
-                    //         for (const refType of oneOfRefTypes) {
-                    //             const types = (refLookup[refType as keyof typeof refLookup] as NBTSubSchema).type ?? schema.type;
-                    //             if (!types) continue;
-                    //             inlineRefTypes.oneOf.push(
-                    //                 Array.isArray(types)
-                    //                     ? types
-                    //                           .map((t: string): string =>
-                    //                               buildTypeForTag(t, refLookup[refType as keyof typeof refLookup] as NBTSubSchema, indent, opts, ctx)
-                    //                           )
-                    //                           .join("|")
-                    //                     : buildTypeForTag(types, refLookup[refType as keyof typeof refLookup] as NBTSubSchema, indent, opts, ctx)
-                    //             );
-                    //         }
-                    // }
-                    if (Array.isArray(resolvedSchema.type)) {
-                        const types = resolvedSchema.type.map((t) => {
-                            const built = buildTypeForTag(t, resolvedSchema, indent, opts, ctx);
-                            if (opts.emitHelperTypes) {
-                                const helperName = makeHelperName("NBT", ctx);
-                                ctx.helperTypes.push(`export type ${helperName} = ${built};`);
-                                return helperName;
+                        if (oneOfRefTypes)
+                            for (const refType of oneOfRefTypes) {
+                                const types = refLookup[refType].type ?? resolvedSchema.type;
+                                if (!types)
+                                    continue;
+                                inlineRefTypes.oneOf.push(Array.isArray(types)
+                                    ? types
+                                        .map((t) => buildTypeForTag(t, refLookup[refType], indent, opts, ctx))
+                                        .join("|")
+                                    : buildTypeForTag(types, refLookup[refType], indent, opts, ctx));
                             }
-                            return built;
-                        });
-                        return `(${types.join(" | ")})`;
-                        // if (opts.inlineRefs ?? false) {
-                        //     return `(${types.join(" | ")})${inlineRefTypes.allOf ? ` & ${inlineRefTypes.allOf.join(" & ")}` : ""}${
-                        //         inlineRefTypes.oneOf ? ` & (${inlineRefTypes.oneOf.join(" | ")})` : ""
-                        //     }`;
-                        // } else {
-                        //     return `(${types.join(" | ")})${allOfRefTypes ? ` & ${allOfRefTypes.join(" & ")}` : ""}${
-                        //         oneOfRefTypes ? ` & (${oneOfRefTypes.join(" | ")})` : ""
-                        //     }`;
-                        // }
                     }
-                    const st = resolvedSchema.type;
                     if (!st) {
                         if (resolvedSchema.properties) {
-                            return buildTypeForTag("compound", resolvedSchema, indent, opts, ctx);
+                            const compoundType = buildTypeForTag("compound", resolvedSchema, indent, opts, ctx);
+                            return opts.inlineRefs ?? false
+                                ? `${(allOfRefTypes || oneOfRefTypes) && /^\{\s*\}$/.test(compoundType) ? "" : `(${compoundType})`}${inlineRefTypes.allOf ? ` & ${inlineRefTypes.allOf.join(" & ")}` : ""}${inlineRefTypes.oneOf ? ` & (${inlineRefTypes.oneOf.join(" | ")})` : ""}`
+                                : `${(allOfRefTypes || oneOfRefTypes) && /^\{\s*\}$/.test(compoundType) ? "" : `(${compoundType})`}${allOfRefTypes ? ` & ${allOfRefTypes.join(" & ")}` : ""}${oneOfRefTypes ? ` & (${oneOfRefTypes.join(" | ")})` : ""}`.replace(/^ & /, "");
+                        }
+                        if (!(opts.inlineRefs ?? false) && schema.$ref) {
+                            const refType = refLookup[resolveSchemaRefName(schema.$ref, false, opts)]
+                                ?.type;
+                            return mainSchemaRefName;
                         }
-                        return "any";
+                        return `{ type: unknown, value: any }`;
                     }
-                    return buildTypeForTag(st, resolvedSchema, indent, opts, ctx);
+                    const builtType = buildTypeForTag(st, resolvedSchema, indent, opts, ctx);
+                    return opts.inlineRefs ?? false
+                        ? `${(allOfRefTypes || oneOfRefTypes) && /^\{\s*\}$/.test(builtType) ? "" : `(${builtType})`}${inlineRefTypes.allOf ? ` & ${inlineRefTypes.allOf.join(" & ")}` : ""}${inlineRefTypes.oneOf ? ` & (${inlineRefTypes.oneOf.join(" | ")})` : ""}`.replace(/^ & /, "")
+                        : `${(allOfRefTypes || oneOfRefTypes) && /^\{\s*\}$/.test(builtType) ? "" : `(${builtType})`}${allOfRefTypes ? ` & ${allOfRefTypes.join(" & ")}` : ""}${oneOfRefTypes ? ` & (${oneOfRefTypes.join(" | ")})` : ""}`.replace(/^ & /, "");
                 }
                 /**
                  * Generates a TypeScript type from a top-level {@link NBTSchema} or {@link NBTSchemaFragment}.
@@ -8782,7 +8883,7 @@ however when the corresponding block in the block layer is broken, this block ge
                 //             if (schema.additionalProperties === true) {
                 //                 extendsLines.push(`Omit<{ [key: string]: { type: any, value: any } }, never>`);
                 //             } else {
-                //                 extendsLines.push(`Omit<{ [key: string]: ${schemaToType(schema.additionalProperties, indent + "  ", opts, ctx)} }, never>`);
+                //                 extendsLines.push(`Omit<{ [key: string]: ${schemaToType(schema.additionalProperties, indent + "    ", opts, ctx)} }, never>`);
                 //             }
                 //         }
                 //     } else if (opts.allowExtraProps) {