@sandstone-mc/mcdoc-ts-generator 0.1.0

package/dist/typegen/mcdoc/complex/template.d.ts

@@ -0,0 +1,54 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { type NonEmptyList } from '..';
+/**
+ * Arguments that can be passed to the template handler.
+ */
+export type TemplateArgs = {
+    name: string;
+};
+/**
+ * Handles `template` types which are generic type definitions.
+ *
+ * A template type has:
+ * - `typeParams`: The generic definitions (e.g., `<T, U>`)
+ * - `child`: The actual type definition that uses those generics
+ *
+ * Example mcdoc:
+ * ```mcdoc
+ * type Template<A, B> = struct {
+ *     first: A,
+ *     second: B,
+ * }
+ * ```
+ *
+ * Generates a TypeScript type alias:
+ * ```ts
+ * type Template<A, B> = { first: A; second: B }
+ * ```
+ */
+declare function mcdoc_template(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeNode;
+} | {
+    readonly child_dispatcher: [parent_count: number, property: string][] & {
+        0: [parent_count: number, property: string];
+    };
+    readonly type: ts.TypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TypeNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly child_dispatcher: [parent_count: number, property: string][] & {
+        0: [parent_count: number, property: string];
+    };
+    readonly type: ts.TypeNode;
+};
+export declare const McdocTemplate: typeof mcdoc_template;
+export {};

package/dist/typegen/mcdoc/dispatcher_symbol.d.ts

@@ -0,0 +1,58 @@
+import ts from 'typescript';
+import type { SymbolMap, SymbolUtil } from '@spyglassmc/core';
+import { type NonEmptyList } from '.';
+export type DispatcherReferenceCounter = {
+    /**
+     * Map<path: string, location_counts_index: number>
+     */
+    locations: Map<string, number>;
+    location_counts: [path: string, count: number][];
+};
+export declare const dispatcher_references: Map<string, DispatcherReferenceCounter>;
+type DispatcherSymbolResult = {
+    /**
+     * The main exported type `SymbolName<CASE>` and all supporting type aliases (member types, map, keys, fallback, unknown)
+     */
+    readonly types: (ts.TypeAliasDeclaration | ts.EnumDeclaration)[];
+    /**
+     * Import paths required by this dispatcher
+     */
+    readonly imports?: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly references?: DispatcherReferenceCounter;
+    /**
+     * Number of required generic parameters for this dispatcher (excluding CASE).
+     * Determined by whether the first member is a template type.
+     */
+    readonly generic_count: number;
+};
+/**
+ * Generates a dispatcher symbol map with the following structure:
+ * ```ts
+ * export type NameFallbackType<T> = { ... }  // Only if %unknown is present
+ * type NameNoneType<T> = { ... }  // Only if %none is present
+ * type NameMemberA<T> = { ... }
+ * type NameMemberB<T> = { ... }
+ * type NameMap<T> = { 'a': NameMemberA<T>, 'b': NameMemberB<T> }
+ * type NameKeys = keyof NameMap<unknown>
+ * type NameFallback<T> = NameMemberA<T> | NameMemberB<T> | NameFallbackType<T>
+ * export type SymbolName<T, CASE extends ('map' | 'keys' | '%fallback' | '%none') = 'map'> = ...
+ * ```
+ *
+ * Generic parameters (e.g., `<T>`) are only present if the dispatcher members are template types.
+ * When present, generics are extracted from the first member and propagated to all type aliases.
+ * CASE always comes after any dispatcher generics in the main Symbol type because required type generics must proceed optional ones.
+ *
+ * Special keys in dispatcher members:
+ * - `%unknown`: Defines fallback type for arbitrary string keys not in the map, doesn't actually work because of TypeScript limitations
+ * - `%none`: Indicates the dispatcher key can be omitted. Handled during dispatcher use.
+ *
+ * Also populates `dispatcherPropertiesMap` with the dispatcher's properties.
+ */
+export declare function dispatcher_symbol(id: string, name: string, members: SymbolMap, dispatcher_properties: Map<string, {
+    supports_none?: true;
+}>, module_map: SymbolMap, symbols: SymbolUtil): DispatcherSymbolResult;
+export declare const DispatcherSymbol: typeof dispatcher_symbol;
+export {};

package/dist/typegen/mcdoc/index.d.ts

@@ -0,0 +1,425 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+export type NonEmptyList<T> = T[] & {
+    0: T;
+};
+export type TypeHandlerResult = {
+    readonly type: ts.TypeNode | ts.TypeAliasDeclaration;
+    readonly imports?: {
+        /**
+         * Cannot include duplicates, but uses a list to preserve order.
+         */
+        readonly ordered: NonEmptyList<string>;
+        /**
+         * Maps import strings to the the index in `ordered` where they appear.
+         */
+        readonly check: Map<string, number>;
+    };
+    readonly docs?: NonEmptyList<string | [string]>;
+    readonly child_dispatcher?: NonEmptyList<[parent_count: number, property: string]>;
+};
+export type TypeHandler<RESULT = TypeHandlerResult> = (type: mcdoc.McdocType) => ((args: Record<string, unknown>) => RESULT);
+declare class TypeHandlersClass {
+    static readonly any: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+    };
+    static readonly boolean: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.KeywordTypeNode<ts.SyntaxKind.BooleanKeyword>;
+    };
+    /**
+     * An `NBTByte`.
+     *
+     * Contains a generic with the actual range encoded:
+     * ```ts
+     * { min?: number; max?: number, leftExclusive?: boolean; rightExclusive?: boolean }
+     * ```
+     */
+    static readonly byte: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode;
+        readonly docs: NonEmptyList<string>;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    /**
+     * An `NBTByteArray`.
+     *
+     * Contains a generic with the length range encoded when applicable.
+     */
+    static readonly byte_array: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            ordered: NonEmptyList<string>;
+            check: Map<string, number>;
+        };
+        readonly docs: NonEmptyList<string>;
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            ordered: NonEmptyList<string>;
+            check: Map<string, number>;
+        };
+        readonly docs?: never;
+    };
+    /**
+     * A type reference with generic parameters.
+     *
+     * References `template` types or members of a dispatcher that include their own generics.
+     */
+    static readonly concrete: McdocConcreteType;
+    /**
+     * `Dispatcher['namespace:...']...`
+     *
+     * With no generic defaults to `map`. Can include a generic parameter for special cases.
+     * - `map`: The full symbol map.
+     * - `keys`: The keys of the symbol map.
+     * - `%fallback`: The union of all symbol values.
+     * - `%unknown`: The intersection of all symbol values.
+     */
+    static readonly dispatcher: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    } | {
+        readonly child_dispatcher: [parent_count: number, property: string][] & {
+            0: [parent_count: number, property: string];
+        };
+        readonly type: ts.TypeNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    static readonly double: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.ParenthesizedTypeNode;
+        readonly docs: NonEmptyList<string>;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    } | {
+        readonly type: ts.ParenthesizedTypeNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    static readonly enum: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.ParenthesizedTypeNode;
+    };
+    static readonly float: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+        readonly docs: NonEmptyList<string>;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    /**
+     * Indexes into a dispatcher type to access a specific property.
+     *
+     * Used for accessing nested properties from dispatched types, e.g.:
+     * `minecraft:environment_attribute[[%key]][attribute_track]`
+     *
+     * Generates indexed access types like:
+     * `SymbolEnvironmentAttribute[K]['attribute_track']`
+     */
+    static readonly indexed: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    } | {
+        readonly child_dispatcher: [parent_count: number, property: string][] & {
+            0: [parent_count: number, property: string];
+        };
+        readonly type: ts.TypeNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    /**
+     * An `NBTInt`.
+     *
+     * Contains a generic with the actual range encoded:
+     * ```ts
+     * { min?: number; max?: number, beginExclusive?: boolean; endExclusive?: boolean }
+     * ```
+     */
+    static readonly int: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode;
+        readonly docs: NonEmptyList<string>;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    /**
+     * An `NBTIntArray`.
+     *
+     * Contains a generic with the length range encoded when applicable.
+     */
+    static readonly int_array: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            ordered: NonEmptyList<string>;
+            check: Map<string, number>;
+        };
+        readonly docs: NonEmptyList<string>;
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            ordered: NonEmptyList<string>;
+            check: Map<string, number>;
+        };
+        readonly docs?: never;
+    };
+    /**
+     * An `NBTList`.
+     */
+    static readonly list: McdocListType;
+    static readonly literal: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.LiteralTypeNode;
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    /**
+     * An `NBTLong`.
+     */
+    static readonly long: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode;
+        readonly docs: NonEmptyList<string>;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    /**
+     * An `NBTLongArray`.
+     *
+     * Contains a generic with the length range encoded when applicable.
+     */
+    static readonly long_array: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            ordered: NonEmptyList<string>;
+            check: Map<string, number>;
+        };
+        readonly docs: NonEmptyList<string>;
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            ordered: NonEmptyList<string>;
+            check: Map<string, number>;
+        };
+        readonly docs?: never;
+    };
+    /**
+     * @deprecated Unused.
+     */
+    static readonly mapped: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+    };
+    static readonly reference: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    } | {
+        readonly child_dispatcher: [[0, string]];
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    } | {
+        readonly docs: (string | [string])[] & {
+            0: string | [string];
+        };
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    } | {
+        readonly docs: (string | [string])[] & {
+            0: string | [string];
+        };
+        readonly child_dispatcher: [[0, string]];
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    } | {
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    } | {
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+        readonly child_dispatcher: [[0, string]];
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    } | {
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+        readonly docs: (string | [string])[] & {
+            0: string | [string];
+        };
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    } | {
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+        readonly docs: (string | [string])[] & {
+            0: string | [string];
+        };
+        readonly child_dispatcher: [[0, string]];
+        readonly type: ts.TypeReferenceNode | ts.ParenthesizedTypeNode;
+    };
+    /**
+     * An `NBTShort`.
+     *
+     * Contains a generic with the actual range encoded:
+     * ```ts
+     * { min?: number; max?: number, beginExclusive?: boolean; endExclusive?: boolean }
+     * ```
+     */
+    static readonly short: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.TypeReferenceNode;
+        readonly docs: NonEmptyList<string>;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    } | {
+        readonly type: ts.TypeReferenceNode;
+        readonly imports: {
+            readonly ordered: NonEmptyList<string>;
+            readonly check: Map<string, number>;
+        };
+    };
+    static readonly string: (type: mcdoc.McdocType) => ((args: Record<string, unknown>) => {
+        readonly type: ts.KeywordTypeNode<ts.SyntaxKind.StringKeyword>;
+    }) | ((args: Record<string, unknown>) => {
+        readonly type: ts.TemplateLiteralTypeNode;
+    }) | ((args: Record<string, unknown>) => {
+        readonly type: ts.TemplateLiteralTypeNode;
+        readonly docs: NonEmptyList<string>;
+        readonly imports?: never;
+    } | {
+        readonly type: ts.TypeNode;
+        readonly imports: {
+            ordered: NonEmptyList<string>;
+            check: Map<string, number>;
+        };
+        readonly docs?: never;
+    }) | ((args: Record<string, unknown>) => {
+        readonly type: ts.UnionTypeNode;
+    }) | ((args: Record<string, unknown>) => {
+        readonly type: ts.ParenthesizedTypeNode;
+    });
+    static readonly struct: McdocStructType;
+    /**
+     * A type alias with generic parameters.
+     *
+     * Is referenced with `concrete` types.
+     */
+    static readonly template: McdocTemplateType;
+    /**
+     * Used in a single place, CubicBezier. Lol.
+     */
+    static readonly tuple: McdocTupleType;
+    static readonly union: McdocUnionType;
+    /**
+     * @deprecated Unused.
+     */
+    static readonly unsafe: (type: mcdoc.McdocType) => (args: Record<string, unknown>) => {
+        readonly type: ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+    };
+}
+export declare const TypeHandlers: typeof TypeHandlersClass;
+/**
+ * Used to broaden the `type` field in the `TypeHandlerResult` for top-level typegen handling.
+ */
+export declare function get_type_handler(type: mcdoc.McdocType): TypeHandler;
+type McdocListType = TypeHandler<{
+    readonly child_dispatcher?: NonEmptyList<[parent_count: number, property: string]>;
+    readonly type: ts.TypeReferenceNode;
+    readonly imports?: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs?: NonEmptyList<string | [string]>;
+}>;
+type McdocStructType = TypeHandler<{
+    readonly child_dispatcher?: NonEmptyList<[parent_count: number, property: string]>;
+    readonly type: ts.TypeLiteralNode | ts.TypeReferenceNode | ts.ParenthesizedTypeNode | ts.KeywordTypeNode<ts.SyntaxKind.UnknownKeyword>;
+    readonly imports?: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs?: NonEmptyList<string | [string]>;
+}>;
+type McdocTupleType = TypeHandler<{
+    readonly docs?: NonEmptyList<string | [string]>;
+    readonly child_dispatcher?: NonEmptyList<[parent_count: number, property: string]>;
+    readonly imports?: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TupleTypeNode;
+}>;
+type McdocUnionType = TypeHandler<{
+    readonly docs?: NonEmptyList<string | [string]>;
+    readonly child_dispatcher?: NonEmptyList<[number, string]>;
+    readonly imports?: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TypeNode;
+}>;
+type McdocConcreteType = TypeHandler<{
+    readonly docs?: NonEmptyList<string | [string]>;
+    readonly child_dispatcher?: NonEmptyList<[parent_count: number, property: string]>;
+    readonly type: ts.TypeReferenceNode | ts.TypeNode;
+    readonly imports?: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+}>;
+type McdocTemplateType = TypeHandler<{
+    readonly child_dispatcher?: NonEmptyList<[parent_count: number, property: string]>;
+    readonly type: ts.TypeNode;
+    readonly imports?: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly docs: never;
+}>;
+export {};

package/dist/typegen/mcdoc/list/array/byte.d.ts

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '../..';
+declare function mcdoc_byte_array(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        ordered: NonEmptyList<string>;
+        check: Map<string, number>;
+    };
+    readonly docs: NonEmptyList<string>;
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        ordered: NonEmptyList<string>;
+        check: Map<string, number>;
+    };
+    readonly docs?: never;
+};
+export declare const McdocByteArray: typeof mcdoc_byte_array;
+export {};

package/dist/typegen/mcdoc/list/array/index.d.ts

@@ -0,0 +1,3 @@
+export { McdocByteArray } from './byte';
+export { McdocIntArray } from './int';
+export { McdocLongArray } from './long';

package/dist/typegen/mcdoc/list/array/int.d.ts

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '../..';
+declare function mcdoc_int_array(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        ordered: NonEmptyList<string>;
+        check: Map<string, number>;
+    };
+    readonly docs: NonEmptyList<string>;
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        ordered: NonEmptyList<string>;
+        check: Map<string, number>;
+    };
+    readonly docs?: never;
+};
+export declare const McdocIntArray: typeof mcdoc_int_array;
+export {};

package/dist/typegen/mcdoc/list/array/long.d.ts

@@ -0,0 +1,20 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import type { NonEmptyList } from '../..';
+declare function mcdoc_long_array(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        ordered: NonEmptyList<string>;
+        check: Map<string, number>;
+    };
+    readonly docs: NonEmptyList<string>;
+} | {
+    readonly type: ts.TypeReferenceNode;
+    readonly imports: {
+        ordered: NonEmptyList<string>;
+        check: Map<string, number>;
+    };
+    readonly docs?: never;
+};
+export declare const McdocLongArray: typeof mcdoc_long_array;
+export {};

package/dist/typegen/mcdoc/list/index.d.ts

@@ -0,0 +1,2 @@
+export { McdocList } from './list';
+export { McdocByteArray, McdocIntArray, McdocLongArray } from './array';

package/dist/typegen/mcdoc/list/list.d.ts

@@ -0,0 +1,66 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+import { type NonEmptyList } from '..';
+declare function mcdoc_list(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+} | {
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeReferenceNode;
+    readonly docs: NonEmptyList<string>;
+} | {
+    readonly type: ts.TypeReferenceNode;
+} | {
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeReferenceNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly type: ts.TypeReferenceNode;
+} | {
+    readonly imports: {
+        readonly ordered: NonEmptyList<string>;
+        readonly check: Map<string, number>;
+    };
+    readonly child_dispatcher: [number, string][] & {
+        0: [number, string];
+    };
+    readonly type: ts.TypeReferenceNode;
+};
+export declare const McdocList: typeof mcdoc_list;
+/**
+ * Generates TypeScript property signatures and documentation for a length range constraint.
+ * Used by list and primitive array types (byte_array, int_array, long_array).
+ *
+ * @param range The numeric range constraint
+ * @param label Label for docs (e.g., "List", "Array")
+ * @returns Object with `generic` (property signatures) and `docs` (documentation strings)
+ */
+export declare function length_range_generic(range: mcdoc.NumericRange, label: string): {
+    generic: ts.PropertySignature[];
+    docs: NonEmptyList<string>;
+};
+export {};

package/dist/typegen/mcdoc/multi/enum.d.ts

@@ -0,0 +1,8 @@
+import ts from 'typescript';
+import * as mcdoc from '@spyglassmc/mcdoc';
+export declare function enum_docs(enum_type: mcdoc.EnumType): string[];
+declare function mcdoc_enum(type: mcdoc.McdocType): (args: Record<string, unknown>) => {
+    readonly type: ts.ParenthesizedTypeNode;
+};
+export declare const McdocEnum: typeof mcdoc_enum;
+export {};

package/dist/typegen/mcdoc/multi/index.d.ts

@@ -0,0 +1,4 @@
+export { McdocEnum } from './enum';
+export { McdocStruct } from './struct';
+export { McdocTuple } from './tuple';
+export { McdocUnion } from './union';