@haneullabs/codegen 0.1.0 → 0.8.3

package/package.json

@@ -1,32 +1,33 @@
 {
   "name": "@haneullabs/codegen",
-  "version": "0.1.0",
-  "description": "typescript codegen for Haneul Move",
+  "version": "0.8.3",
+  "description": "typescript codegen for haneul move",
   "license": "Apache-2.0",
-  "author": "Haneul Labs <build@haneullabs.com>",
+  "author": "Haneul Labs <build@haneul-labs.com>",
   "sideEffects": false,
-  "type": "commonjs",
-  "main": "./dist/cjs/index.js",
-  "module": "./dist/esm/index.js",
-  "types": "./dist/cjs/index.d.ts",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "exports": {
     ".": {
-      "import": "./dist/esm/index.js",
-      "require": "./dist/cjs/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     }
   },
   "files": [
     "CHANGELOG.md",
     "dist",
+    "docs",
     "src"
   ],
   "bin": {
-    "haneul-ts-codegen": "dist/cjs/bin/cli.js",
-    "__haneul-ts-codegen_bash_complete": "dist/cjs/bin/bash-complete.js"
+    "haneul-ts-codegen": "dist/bin/cli.mjs",
+    "__haneul-ts-codegen_bash_complete": "dist/bin/bash-complete.mjs"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/GeunhwaJeong/haneul-ts-sdks.git"
+    "url": "git+https://github.com/GeunhwaJeong/ts-sdks.git"
   },
   "keywords": [
     "move",
@@ -34,37 +35,37 @@
     "haneul"
   ],
   "bugs": {
-    "url": "https://github.com/GeunhwaJeong/haneul-ts-sdks/issues"
+    "url": "https://github.com/GeunhwaJeong/ts-sdks/issues"
   },
-  "homepage": "https://github.com/GeunhwaJeong/haneul-ts-sdks/blob/main/packages/codegen#readme",
+  "homepage": "https://github.com/GeunhwaJeong/ts-sdks/blob/main/packages/codegen#readme",
   "devDependencies": {
-    "vitest": "^4.0.15",
-    "@haneullabs/build-scripts": "0.1.0"
+    "vitest": "^4.0.17"
   },
   "dependencies": {
-    "@stricli/auto-complete": "^1.2.4",
-    "@stricli/core": "^1.2.4",
-    "@types/node": "^24.10.1",
+    "@stricli/auto-complete": "^1.2.5",
+    "@stricli/core": "^1.2.5",
+    "@types/node": "^25.0.8",
     "cosmiconfig": "^9.0.0",
-    "prettier": "^3.7.3",
+    "prettier": "^3.7.4",
     "toml": "^3.0.0",
     "typescript": "^5.9.3",
-    "zod": "^3.25.67",
-    "@haneullabs/bcs": "0.1.0",
-    "@haneullabs/haneul": "0.1.0"
+    "zod": "^4.3.5",
+    "@haneullabs/bcs": "^2.0.3",
+    "@haneullabs/haneul": "^2.13.0"
   },
   "scripts": {
     "clean": "rm -rf tsconfig.tsbuildinfo ./dist",
     "dev": "pnpm build --watch",
-    "build": "build-package",
+    "build": "rm -rf dist && tsc --noEmit && tsdown",
+    "build:docs": "tsx ../docs/scripts/build-docs.ts",
     "codegen": "pnpm tsx src/bin/cli.ts generate && pnpm lint:fix",
     "test": "vitest run",
     "test:watch": "vitest",
     "prettier:check": "prettier -c --ignore-unknown .",
     "prettier:fix": "prettier -w --ignore-unknown .",
-    "eslint:check": "eslint --max-warnings=0 .",
-    "eslint:fix": "pnpm run eslint:check --fix",
-    "lint": "pnpm run eslint:check && pnpm run prettier:check",
-    "lint:fix": "pnpm run eslint:fix && pnpm run prettier:fix"
+    "oxlint:check": "oxlint  .",
+    "oxlint:fix": "oxlint --fix",
+    "lint": "pnpm run oxlint:check && pnpm run prettier:check",
+    "lint:fix": "pnpm run oxlint:fix && pnpm run prettier:fix"
   }
 }

package/src/bin/bash-complete.ts

@@ -3,19 +3,30 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import { proposeCompletions } from '@stricli/core';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
 import { buildContext } from '../cli/context.js';
 import { buildCli } from '../cli/cli.js';
 
-const { version }: { version: string } = require('../../../package.json');
-const cli = buildCli(version);
-
-const inputs = process.argv.slice(3);
-if (process.env['COMP_LINE']?.endsWith(' ')) {
-	inputs.push('');
+async function getVersion() {
+	// @ts-ignore
+	const dirname = import.meta.dirname;
+	const packageJsonPath = resolve(
+		dirname,
+		dirname.endsWith('src/bin') ? '../../package.json' : '../../package.json',
+	);
+	const packageJson: { version: string } = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
+	return packageJson.version;
 }
 
 export async function main() {
-	await proposeCompletions(cli, inputs, buildContext(process));
+	const version = await getVersion();
+	const cli = buildCli(version);
+
+	const inputs = process.argv.slice(3);
+	if (process.env['COMP_LINE']?.endsWith(' ')) {
+		inputs.push('');
+	}
 
 	try {
 		for (const { completion } of await proposeCompletions(cli, inputs, buildContext(process))) {

package/src/bin/cli.ts

@@ -9,18 +9,12 @@ import { readFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
 async function getVersion() {
-	let dirname;
-
-	try {
-		dirname = __dirname;
-	} catch {
-		// @ts-ignore
-		dirname = import.meta.dirname;
-	}
+	// @ts-ignore
+	const dirname = import.meta.dirname;
 
 	const packageJsonPath = resolve(
 		dirname,
-		dirname.endsWith('src/bin') ? '../../package.json' : '../../../package.json',
+		dirname.endsWith('src/bin') ? '../../package.json' : '../../package.json',
 	);
 	const packageJson: { version: string } = JSON.parse(await readFile(packageJsonPath, 'utf-8'));
 	return packageJson.version;

package/src/cli/commands/generate/command.ts

@@ -38,10 +38,42 @@ export const generateCommand = buildCommand({
 				optional: true,
 				brief: 'Network to generate for (default: testnet)',
 			},
+			importExtension: {
+				kind: 'enum',
+				values: ['.js', '.ts', 'none'],
+				optional: true,
+				brief: 'File extension for import statements (default: .js)',
+			},
+			modules: {
+				kind: 'parsed',
+				parse: String,
+				optional: true,
+				variadic: ',',
+				brief: 'Only generate from these modules (comma-separated)',
+			},
+			noTypes: {
+				kind: 'parsed',
+				parse: Boolean,
+				optional: true,
+				brief: 'Skip type generation',
+			},
+			noFunctions: {
+				kind: 'parsed',
+				parse: Boolean,
+				optional: true,
+				brief: 'Skip function generation',
+			},
+			private: {
+				kind: 'enum',
+				values: ['none', 'entry', 'all'],
+				optional: true,
+				brief: 'Which private functions to generate (default: entry)',
+			},
 		},
 		aliases: {
 			o: 'outputDir',
 			n: 'network',
+			m: 'modules',
 		},
 	},
 	docs: {

package/src/cli/commands/generate/impl.ts

@@ -3,16 +3,23 @@
 
 import type { LocalContext } from '../../context.js';
 import { generateFromPackageSummary } from '../../../index.js';
-import { loadConfig } from '../../../config.js';
+import { loadConfig, type GenerateBase, type PackageGenerate } from '../../../config.js';
 import { isValidNamedPackage, isValidHaneulObjectId } from '@haneullabs/haneul/utils';
 import { execSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
 
 export interface SubdirCommandFlags {
 	outputDir?: string;
 	noPrune?: boolean;
 	noSummaries?: boolean;
 	network?: 'mainnet' | 'testnet';
+	importExtension?: '.js' | '.ts' | 'none';
+	modules?: string[];
+	noTypes?: boolean;
+	noFunctions?: boolean;
+	private?: 'none' | 'entry' | 'all';
 }
 
 export default async function generate(
@@ -31,6 +38,7 @@ export default async function generate(
 							network: flags.network ?? 'testnet',
 							packageName: isValidHaneulObjectId(trimmed) ? trimmed : trimmed.split('/')[1],
 							package: trimmed,
+							packageId: isValidHaneulObjectId(trimmed) ? trimmed : undefined,
 						};
 					} else {
 						return {
@@ -45,8 +53,53 @@ export default async function generate(
 	const generateSummaries =
 		flags.noSummaries === undefined ? config.generateSummaries : !flags.noSummaries;
 
+	const cliPrivate =
+		flags.private !== undefined
+			? flags.private === 'all'
+				? true
+				: flags.private === 'none'
+					? false
+					: 'entry'
+			: undefined;
+
+	const cliGenerate: PackageGenerate | undefined =
+		flags.modules !== undefined ||
+		flags.noTypes !== undefined ||
+		flags.noFunctions !== undefined ||
+		flags.private !== undefined
+			? {
+					...(flags.modules !== undefined && { modules: flags.modules }),
+					...(flags.noTypes !== undefined && { types: !flags.noTypes as boolean }),
+					...(flags.noFunctions !== undefined || flags.private !== undefined
+						? {
+								functions: flags.noFunctions
+									? false
+									: cliPrivate !== undefined
+										? { private: cliPrivate }
+										: true,
+							}
+						: {}),
+				}
+			: undefined;
+
 	for (const pkg of normalizedPackages) {
-		if (generateSummaries && pkg.path) {
+		// Detect on-chain packages: they have 'network' field and no 'path'
+		const isOnChainPackage =
+			('packageId' in pkg && pkg.packageId) || ('network' in pkg && !('path' in pkg));
+
+		// Generate summaries for on-chain packages using --package-id
+		if (isOnChainPackage) {
+			const packageId = 'packageId' in pkg ? pkg.packageId : pkg.package;
+			const tempDir = mkdtempSync(join(tmpdir(), 'haneul-codegen-'));
+			console.log(`Generating summary for on-chain package ${packageId} to ${tempDir}`);
+
+			execSync(`haneul move summary --package-id ${packageId} --output-directory ${tempDir}`, {
+				stdio: 'inherit',
+			});
+
+			// Set the path to use the generated summary directory
+			(pkg as { path?: string }).path = tempDir;
+		} else if (generateSummaries && pkg.path) {
 			if (!existsSync(pkg.path)) {
 				throw new Error(`Package path does not exist: ${pkg.path}`);
 			}
@@ -56,11 +109,46 @@ export default async function generate(
 				stdio: 'inherit',
 			});
 		}
+		const importExtension =
+			flags.importExtension === undefined
+				? config.importExtension
+				: flags.importExtension === 'none'
+					? ''
+					: flags.importExtension;
+
+		const pkgWithOverrides = cliGenerate
+			? {
+					...pkg,
+					generate: {
+						...('generate' in pkg ? pkg.generate : {}),
+						...cliGenerate,
+					},
+				}
+			: pkg;
+
+		// Fold deprecated privateMethods into globalGenerate
+		const globalGenerate: GenerateBase | undefined =
+			config.privateMethods && !config.generate?.functions
+				? {
+						...config.generate,
+						functions: {
+							private:
+								config.privateMethods === 'all'
+									? true
+									: config.privateMethods === 'none'
+										? false
+										: 'entry',
+						},
+					}
+				: config.generate;
+
 		await generateFromPackageSummary({
-			package: pkg,
+			package: pkgWithOverrides,
 			prune: flags.noPrune === undefined ? config.prune : !flags.noPrune,
 			outputDir: flags.outputDir ?? config.output,
-			privateMethods: config.privateMethods,
+			globalGenerate,
+			importExtension,
+			includePhantomTypeParameters: config.includePhantomTypeParameters,
 		});
 	}
 }

package/src/config.ts

@@ -5,6 +5,42 @@ import { isValidNamedPackage, isValidHaneulObjectId } from '@haneullabs/haneul/u
 import { cosmiconfig } from 'cosmiconfig';
 import * as z from 'zod/v4';
 
+export const globalFunctionsOptionSchema = z.union([
+	z.boolean(),
+	z.object({
+		private: z.union([z.boolean(), z.literal('entry')]).optional(),
+	}),
+]);
+
+export const functionsOptionSchema = z.union([
+	z.boolean(),
+	z.array(z.string()),
+	z.object({
+		private: z.union([z.boolean(), z.literal('entry')]).optional(),
+	}),
+]);
+
+export const typesOptionSchema = z.union([z.boolean(), z.array(z.string())]);
+
+export const globalGenerateSchema = z.object({
+	functions: globalFunctionsOptionSchema.optional(),
+	types: z.boolean().optional(),
+});
+
+export const moduleGenerateSchema = z.object({
+	functions: functionsOptionSchema.optional(),
+	types: typesOptionSchema.optional(),
+});
+
+export const packageGenerateSchema = globalGenerateSchema.extend({
+	modules: z
+		.union([
+			z.array(z.string()),
+			z.record(z.string(), z.union([z.literal(true), moduleGenerateSchema])),
+		])
+		.optional(),
+});
+
 export const onChainPackageSchema = z.object({
 	package: z.string().refine((name) => isValidNamedPackage(name) || isValidHaneulObjectId(name), {
 		message: 'Invalid package name or package ID',
@@ -12,25 +48,36 @@ export const onChainPackageSchema = z.object({
 	packageName: z.string(),
 	path: z.never().optional(),
 	network: z.enum(['mainnet', 'testnet']),
+	generate: packageGenerateSchema.optional(),
 });
 
 export const localPackageSchema = z.object({
 	path: z.string(),
 	package: z.string(),
 	packageName: z.string().optional(),
+	generate: packageGenerateSchema.optional(),
 });
 
 export const packageConfigSchema = z.union([onChainPackageSchema, localPackageSchema]);
 
+export const importExtensionSchema = z.union([z.literal('.js'), z.literal('.ts'), z.literal('')]);
+export type ImportExtension = z.infer<typeof importExtensionSchema>;
+
+export type GenerateBase = z.infer<typeof globalGenerateSchema>;
+export type PackageGenerate = z.infer<typeof packageGenerateSchema>;
+export type FunctionsOption = z.infer<typeof functionsOptionSchema>;
+export type TypesOption = z.infer<typeof typesOptionSchema>;
+
 export const configSchema = z.object({
 	output: z.string(),
 	prune: z.boolean().optional().default(true),
 	generateSummaries: z.boolean().optional().default(true),
 	packages: z.array(packageConfigSchema),
-	privateMethods: z
-		.union([z.literal('none'), z.literal('entry'), z.literal('all')])
-		.optional()
-		.default('entry'),
+	generate: globalGenerateSchema.optional(),
+	/** @deprecated Use `generate: { functions: { private: 'entry' } }` instead */
+	privateMethods: z.union([z.literal('none'), z.literal('entry'), z.literal('all')]).optional(),
+	importExtension: importExtensionSchema.optional().default('.js'),
+	includePhantomTypeParameters: z.boolean().optional().default(false),
 });
 
 export type PackageConfig = z.infer<typeof packageConfigSchema>;
@@ -46,7 +93,8 @@ export async function loadConfig(): Promise<ParsedHaneulCodegenConfig> {
 			packages: [],
 			prune: true,
 			generateSummaries: true,
-			privateMethods: 'entry',
+			importExtension: '.js',
+			includePhantomTypeParameters: false,
 		};
 	}
 

package/src/file-builder.ts

@@ -13,12 +13,25 @@ export class FileBuilder {
 	starImports: Map<string, string> = new Map();
 	protected reservedNames: Set<string> = new Set();
 
-	addImport(module: string, name: string) {
+	addImport(module: string, name: string): string {
 		if (!this.imports.has(module)) {
 			this.imports.set(module, new Set());
 		}
 
+		const isTypeImport = name.startsWith('type ');
+		const baseName = isTypeImport ? name.slice(5) : name;
+
+		if (this.reservedNames.has(baseName)) {
+			const alias = this.getUnusedName(baseName);
+			const aliasedImport = isTypeImport
+				? `type ${baseName} as ${alias}`
+				: `${baseName} as ${alias}`;
+			this.imports.get(module)!.add(aliasedImport);
+			return alias;
+		}
+
 		this.imports.get(module)!.add(name);
+		return baseName;
 	}
 
 	addStarImport(module: string, name: string) {
@@ -36,6 +49,7 @@ export class FileBuilder {
 			i++;
 		}
 
+		this.reservedNames.add(deConflictedName);
 		return deConflictedName;
 	}
 

package/src/generate-utils.ts

@@ -2,16 +2,36 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export const utilsContent = /* ts */ `
-import { bcs, BcsType, TypeTag, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple } from '@haneullabs/haneul/bcs';
+import {
+	bcs,
+	BcsType,
+	TypeTag,
+	TypeTagSerializer,
+	BcsStruct,
+	BcsEnum,
+	BcsTuple,
+} from '@haneullabs/haneul/bcs';
 import { normalizeHaneulAddress } from '@haneullabs/haneul/utils';
 import { TransactionArgument, isArgument } from '@haneullabs/haneul/transactions';
+import { ClientWithCoreApi, HaneulClientTypes } from '@haneullabs/haneul/client';
 
 const MOVE_STDLIB_ADDRESS = normalizeHaneulAddress('0x1');
 const HANEUL_FRAMEWORK_ADDRESS = normalizeHaneulAddress('0x2');
-const HANEUL_SYSTEM_ADDRESS = normalizeHaneulAddress('0x3');
 
 export type RawTransactionArgument<T> = T | TransactionArgument;
 
+export interface GetOptions<
+	Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {},
+> extends HaneulClientTypes.GetObjectOptions<Include> {
+	client: ClientWithCoreApi;
+}
+
+export interface GetManyOptions<
+	Include extends Omit<HaneulClientTypes.ObjectInclude, 'content'> = {},
+> extends HaneulClientTypes.GetObjectsOptions<Include> {
+	client: ClientWithCoreApi;
+}
+
 export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null {
 	const parsedTag = typeof typeTag === 'string' ? TypeTagSerializer.parseFromStr(typeTag) : typeTag;
 
@@ -36,7 +56,7 @@ export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null
 		return type ? bcs.vector(type) : null;
 	} else if ('struct' in parsedTag) {
 		const structTag = parsedTag.struct;
-		const pkg = normalizeHaneulAddress(parsedTag.struct.address);
+		const pkg = normalizeHaneulAddress(structTag.address);
 
 		if (pkg === MOVE_STDLIB_ADDRESS) {
 			if (
@@ -47,12 +67,16 @@ export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null
 			}
 
 			if (structTag.module === 'option' && structTag.name === 'Option') {
-				const type = getPureBcsSchema(structTag.typeParams[0]!);
+				const type = getPureBcsSchema(structTag.typeParams[0]);
 				return type ? bcs.option(type) : null;
 			}
 		}
 
-		if (pkg === HANEUL_FRAMEWORK_ADDRESS && structTag.module === 'Object' && structTag.name === 'ID') {
+		if (
+			pkg === HANEUL_FRAMEWORK_ADDRESS &&
+			structTag.module === 'object' &&
+			(structTag.name === 'ID' || structTag.name === 'UID')
+		) {
 			return bcs.Address;
 		}
 	}
@@ -60,7 +84,11 @@ export function getPureBcsSchema(typeTag: string | TypeTag): BcsType<any> | null
 	return null;
 }
 
-export function normalizeMoveArguments(args: unknown[] | object, argTypes: string[], parameterNames?: string[]) {
+export function normalizeMoveArguments(
+	args: unknown[] | object,
+	argTypes: readonly (string | null)[],
+	parameterNames?: string[],
+) {
 	const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
 	if (parameterNames && argLen !== parameterNames.length) {
 		throw new Error(
@@ -72,30 +100,32 @@ export function normalizeMoveArguments(args: unknown[] | object, argTypes: strin
 
 	let index = 0;
 	for (const [i, argType] of argTypes.entries()) {
-		if (argType === \`\${HANEUL_FRAMEWORK_ADDRESS}::deny_list::DenyList\`) {
-			normalizedArgs.push((tx) => tx.object.denyList());
+		if (argType === '0x2::clock::Clock') {
+			normalizedArgs.push((tx) => tx.object.clock());
 			continue;
 		}
 
-		if (argType === \`\${HANEUL_FRAMEWORK_ADDRESS}::random::Random\`) {
+		if (argType === '0x2::random::Random') {
 			normalizedArgs.push((tx) => tx.object.random());
 			continue;
 		}
 
-		if (argType === \`\${HANEUL_FRAMEWORK_ADDRESS}::clock::Clock\`) {
-			normalizedArgs.push((tx) => tx.object.clock());
+		if (argType === '0x2::deny_list::DenyList') {
+			normalizedArgs.push((tx) => tx.object.denyList());
 			continue;
 		}
 
-		if (argType === \`\${HANEUL_SYSTEM_ADDRESS}::haneul_system::HaneulSystemState\`) {
+		if (argType === '0x3::haneul_system::HaneulSystemState') {
 			normalizedArgs.push((tx) => tx.object.system());
 			continue;
 		}
 
-		let arg
+		let arg;
 		if (Array.isArray(args)) {
 			if (index >= args.length) {
-				throw new Error(\`Invalid number of arguments, expected at least \${index + 1}, got \${args.length}\`);
+				throw new Error(
+					\`Invalid number of arguments, expected at least \${index + 1}, got \${args.length}\`,
+				);
 			}
 			arg = args[index];
 		} else {
@@ -117,8 +147,8 @@ export function normalizeMoveArguments(args: unknown[] | object, argTypes: strin
 			continue;
 		}
 
-		const type = argTypes[i]!;
-		const bcsType = getPureBcsSchema(type);
+		const type = argTypes[i];
+		const bcsType = type === null ? null : getPureBcsSchema(type);
 
 		if (bcsType) {
 			const bytes = bcsType.serialize(arg as never);
@@ -138,7 +168,47 @@ export function normalizeMoveArguments(args: unknown[] | object, argTypes: strin
 export class MoveStruct<
 	T extends Record<string, BcsType<any>>,
 	const Name extends string = string,
-> extends BcsStruct<T, Name> {}
+> extends BcsStruct<T, Name> {
+	async get<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
+		objectId,
+		...options
+	}: GetOptions<Include>): Promise<
+		HaneulClientTypes.Object<Include & { content: true, json: true }> & { json: BcsStruct<T>['$inferType'] }
+	> {
+		const [res] = await this.getMany<Include>({
+			...options,
+			objectIds: [objectId],
+		});
+
+		return res;
+	}
+
+	async getMany<Include extends Omit<HaneulClientTypes.ObjectInclude, 'content' | 'json'> = {}>({
+		client,
+		...options
+	}: GetManyOptions<Include>): Promise<
+		Array<HaneulClientTypes.Object<Include & { content: true, json: true }> & { json: BcsStruct<T>['$inferType'] }>
+	> {
+		const response = (await client.core.getObjects({
+			...options,
+			include: {
+				...options.include,
+				content: true,
+			},
+		})) as HaneulClientTypes.GetObjectsResponse<Include & { content: true }>;
+
+		return response.objects.map((obj) => {
+			if (obj instanceof Error) {
+				throw obj;
+			}
+
+			return {
+				...obj,
+				json: this.parse(obj.content),
+			};
+		});
+	}
+}
 
 export class MoveEnum<
 	T extends Record<string, BcsType<any> | null>,
@@ -146,7 +216,7 @@ export class MoveEnum<
 > extends BcsEnum<T, Name> {}
 
 export class MoveTuple<
-	T extends readonly BcsType<any>[],
+	const T extends readonly BcsType<any>[],
 	const Name extends string,
 > extends BcsTuple<T, Name> {}