@pezkuwi/typegen 16.5.5 → 16.5.6

package/src/packageInfo.ts

@@ -1,6 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-// Do not edit, auto-generated by @polkadot/dev
-
-export const packageInfo = { name: '@pezkuwi/typegen', path: 'auto', type: 'auto', version: '16.5.5' };

package/src/util/assert.ts

@@ -1,18 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import fs from 'node:fs';
-
-import { assert } from '@pezkuwi/util';
-
-export function assertDir (path: string): string {
-  assert(fs.existsSync(path) && fs.lstatSync(path).isDirectory(), `${path} is not a directory`);
-
-  return path;
-}
-
-export function assertFile (path: string): string {
-  assert(fs.existsSync(path) && fs.lstatSync(path).isFile(), `${path} is not a file`);
-
-  return path;
-}

package/src/util/derived.spec.ts

@@ -1,58 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { TypeRegistry } from '@pezkuwi/types/create';
-
-import { getSimilarTypes } from './derived.js';
-
-describe('getSimilarTypes', (): void => {
-  const registry = new TypeRegistry();
-  const mockImports = {
-    codecTypes: {},
-    definitions: {},
-    extrinsicTypes: {},
-    genericTypes: {},
-    ignoredTypes: [],
-    localTypes: {},
-    lookupTypes: {},
-    metadataTypes: {},
-    primitiveTypes: {},
-    typeToModule: {},
-    typesTypes: {}
-  };
-
-  it('handles nested Tuples', (): void => {
-    expect(getSimilarTypes(registry, {}, '(AccountId, (Balance, u32), u64)', mockImports)).toEqual([
-      'ITuple<[AccountId, ITuple<[Balance, u32]>, u64]>',
-      '[AccountId | string | Uint8Array, ITuple<[Balance, u32]> | [Balance | AnyNumber | Uint8Array, u32 | AnyNumber | Uint8Array], u64 | AnyNumber | Uint8Array]'
-    ]);
-  });
-
-  it('handles vectors of slices', (): void => {
-    expect(getSimilarTypes(registry, {}, 'Vec<[u8;4]>', mockImports)).toEqual([
-      'Vec<U8aFixed>'
-    ]);
-    expect(getSimilarTypes(registry, {}, 'Vec<[Balance;8]>', mockImports)).toEqual([
-      'Vec<Vec<Balance>>'
-    ]);
-  });
-
-  it('handles structs', (): void => {
-    expect(getSimilarTypes(registry, {}, '{ "a": "u8", "b": "Vec<u8>" }', mockImports)).toEqual([
-      `{
-    readonly a: u8;
-    readonly b: Bytes;
-  } & Struct`, '{ a?: any; b?: any }', 'string', 'Uint8Array'
-    ]);
-  });
-  it('handles vectors of structs', (): void => {
-    expect(getSimilarTypes(registry, {}, 'Vec<{ "a": "H256", "b": "Vec<H256>" }>', mockImports)).toEqual([
-      `Vec<{
-    readonly a: H256;
-    readonly b: Vec<H256>;
-  } & Struct>`
-    ]);
-  });
-});

package/src/util/derived.ts

@@ -1,133 +0,0 @@
-// Copyright 2017-2025 @polkadot/types authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { CodecClass, Registry } from '@pezkuwi/types/types';
-import type { UInt } from '@pezkuwi/types-codec';
-import type { TypeDef } from '@pezkuwi/types-create/types';
-import type { ModuleTypes, TypeImports } from './imports.js';
-
-import { GenericAccountId, GenericCall, GenericLookupSource, GenericVote } from '@pezkuwi/types/generic';
-import { AllConvictions } from '@pezkuwi/types/interfaces/democracy/definitions';
-import { AbstractInt, bool, Compact, Enum, Null, Option, Struct, Tuple, Vec, WrapperKeepOpaque, WrapperOpaque } from '@pezkuwi/types-codec';
-import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
-import { isChildClass, stringify } from '@pezkuwi/util';
-
-import { formatType } from './formatting.js';
-import { setImports } from './imports.js';
-
-function arrayToStrType (arr: string[]): string {
-  return `${arr.map((c) => `'${c}'`).join(' | ')}`;
-}
-
-const voteConvictions = arrayToStrType(AllConvictions);
-
-// Make types a little bit more flexible
-// - if param instanceof AbstractInt, then param: u64 | Uint8array | AnyNumber
-// etc
-/** @internal */
-export function getSimilarTypes (registry: Registry, definitions: Record<string, ModuleTypes>, _type: string, imports: TypeImports): string[] {
-  const typeParts = _type.split('::');
-  const type = typeParts[typeParts.length - 1];
-  const possibleTypes = [formatType(registry, definitions, type, imports)];
-
-  if (type === 'Extrinsic') {
-    setImports(definitions, imports, ['IExtrinsic']);
-
-    return ['Extrinsic', 'IExtrinsic', 'string', 'Uint8Array'];
-  } else if (type === 'Keys') {
-    // This one is weird... surely it should popup as a Tuple? (but either way better as defined hex)
-    return ['Keys', 'string', 'Uint8Array'];
-  } else if (type === 'StorageKey') {
-    // TODO We can do better
-    return ['StorageKey', 'string', 'Uint8Array', 'any'];
-  } else if (type === '()') {
-    return ['null'];
-  }
-
-  const Clazz = registry.createClass(type);
-
-  if (isChildClass(Vec, Clazz)) {
-    const vecDef = getTypeDef(type);
-    const subDef = (vecDef.sub) as TypeDef;
-
-    // this could be that we define a Vec type and refer to it by name
-    if (subDef) {
-      if (subDef.info === TypeDefInfo.Plain) {
-        possibleTypes.push(`(${getSimilarTypes(registry, definitions, subDef.type, imports).join(' | ')})[]`);
-      } else if (subDef.info === TypeDefInfo.Tuple) {
-        const subs = (subDef.sub as TypeDef[]).map(({ type }): string =>
-          getSimilarTypes(registry, definitions, type, imports).join(' | ')
-        );
-
-        possibleTypes.push(`([${subs.join(', ')}])[]`);
-      } else if (subDef.info === TypeDefInfo.Option || subDef.info === TypeDefInfo.Vec || subDef.info === TypeDefInfo.VecFixed) {
-        // TODO: Add possibleTypes so imports work
-      } else if (subDef.info === TypeDefInfo.Struct) {
-        // TODO: Add possibleTypes so imports work
-      } else {
-        throw new Error(`Unhandled subtype in Vec, ${stringify(subDef)}`);
-      }
-    }
-  } else if (isChildClass(Enum, Clazz)) {
-    const { defKeys, isBasic } = new (Clazz as CodecClass)(registry) as Enum;
-    const keys = defKeys.filter((v) => !v.startsWith('__Unused'));
-
-    if (isBasic) {
-      possibleTypes.push(arrayToStrType(keys), 'number');
-    } else {
-      // TODO We don't really want any here, these should be expanded
-      possibleTypes.push(...keys.map((k) => `{ ${k}: any }`), 'string');
-    }
-
-    possibleTypes.push('Uint8Array');
-  } else if (isChildClass(AbstractInt as unknown as CodecClass<UInt>, Clazz) || isChildClass(Compact, Clazz)) {
-    possibleTypes.push('AnyNumber', 'Uint8Array');
-  } else if (isChildClass(GenericLookupSource, Clazz)) {
-    possibleTypes.push('Address', 'AccountId', 'AccountIndex', 'LookupSource', 'string', 'Uint8Array');
-  } else if (isChildClass(GenericAccountId, Clazz)) {
-    possibleTypes.push('string', 'Uint8Array');
-  } else if (isChildClass(GenericCall, Clazz)) {
-    possibleTypes.push('IMethod', 'string', 'Uint8Array');
-  } else if (isChildClass(bool, Clazz)) {
-    possibleTypes.push('boolean', 'Uint8Array');
-  } else if (isChildClass(Null, Clazz)) {
-    possibleTypes.push('null');
-  } else if (isChildClass(Struct, Clazz)) {
-    const s = new (Clazz as CodecClass)(registry) as Struct;
-    const obj = s.defKeys.map((key): string => `${key}?: any`).join('; ');
-
-    possibleTypes.push(`{ ${obj} }`, 'string', 'Uint8Array');
-  } else if (isChildClass(Option, Clazz)) {
-    possibleTypes.push('null', 'Uint8Array');
-
-    const optDef = getTypeDef(type);
-    const subDef = (optDef.sub) as TypeDef;
-
-    if (subDef) {
-      possibleTypes.push(...getSimilarTypes(registry, definitions, subDef.type, imports));
-    } else {
-      possibleTypes.push('object', 'string');
-    }
-  } else if (isChildClass(GenericVote, Clazz)) {
-    possibleTypes.push(`{ aye: boolean; conviction?: ${voteConvictions} | number }`, 'boolean', 'string', 'Uint8Array');
-  } else if (isChildClass(WrapperKeepOpaque, Clazz) || isChildClass(WrapperOpaque, Clazz)) {
-    // TODO inspect container
-    possibleTypes.push('object', 'string', 'Uint8Array');
-  } else if (isChildClass(Uint8Array, Clazz)) {
-    possibleTypes.push('string', 'Uint8Array');
-  } else if (isChildClass(String, Clazz)) {
-    possibleTypes.push('string');
-  } else if (isChildClass(Tuple, Clazz)) {
-    const tupDef = getTypeDef(type);
-    const subDef = tupDef.sub;
-
-    // this could be that we define a Tuple type and refer to it by name
-    if (Array.isArray(subDef)) {
-      const subs = subDef.map(({ type }) => getSimilarTypes(registry, definitions, type, imports).join(' | '));
-
-      possibleTypes.push(`[${subs.join(', ')}]`);
-    }
-  }
-
-  return [...new Set(possibleTypes)];
-}

package/src/util/docs.ts

@@ -1,13 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import Handlebars from 'handlebars';
-
-import { readTemplate } from './file.js';
-
-Handlebars.registerPartial({
-  docs: Handlebars.compile(readTemplate('docs'))
-});
-
-// empty export
-export const __TYPEGEN_DUMMY_DOCS = 'DUMMY_DOCS';

package/src/util/file.ts

@@ -1,42 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-
-import { packageInfo } from '../packageInfo.js';
-
-export function writeFile (dest: string, generator: () => string, noLog?: boolean): void {
-  !noLog && console.log(`${dest}\n\tGenerating`);
-
-  let generated = generator();
-
-  while (generated.includes('\n\n\n')) {
-    generated = generated.replace(/\n\n\n/g, '\n\n');
-  }
-
-  !noLog && console.log('\tWriting');
-
-  fs.writeFileSync(dest, generated, { flag: 'w' });
-
-  !noLog && console.log('');
-}
-
-export function readTemplate (template: string): string {
-  // Inside the api repo itself, it will be 'auto'
-  const rootDir = packageInfo.path === 'auto'
-    ? path.join(process.cwd(), 'packages/typegen/src')
-    : packageInfo.path;
-
-  // NOTE With cjs in a subdir, search one lower as well
-  const file = ['./templates', '../templates']
-    .map((p) => path.join(rootDir, p, `${template}.hbs`))
-    .find((p) => fs.existsSync(p));
-
-  if (!file) {
-    throw new Error(`Unable to locate ${template}.hbs from ${rootDir}`);
-  }
-
-  return fs.readFileSync(file).toString();
-}

package/src/util/formatting.spec.ts

@@ -1,30 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-/// <reference types="@pezkuwi/dev-test/globals.d.ts" />
-
-import { TypeRegistry } from '@pezkuwi/types';
-
-import { formatType } from './formatting.js';
-
-describe('formatType', (): void => {
-  const registry = new TypeRegistry();
-
-  it('handles nested Tuples', (): void => {
-    expect(
-      formatType(registry, {}, '(AccountId, (Balance, u32), u64)', {
-        codecTypes: {},
-        definitions: {},
-        extrinsicTypes: {},
-        genericTypes: {},
-        ignoredTypes: [],
-        localTypes: {},
-        lookupTypes: {},
-        metadataTypes: {},
-        primitiveTypes: {},
-        typeToModule: {},
-        typesTypes: {}
-      })
-    ).toEqual('ITuple<[AccountId, ITuple<[Balance, u32]>, u64]>');
-  });
-});

package/src/util/formatting.ts

@@ -1,295 +0,0 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
-import type { AnyString, Registry } from '@pezkuwi/types/types';
-import type { LookupString } from '@pezkuwi/types-codec/types';
-import type { TypeDef } from '@pezkuwi/types-create/types';
-import type { ModuleTypes, TypeImports } from './imports.js';
-
-import Handlebars from 'handlebars';
-
-import * as typesCodec from '@pezkuwi/types-codec';
-import { getTypeDef, paramsNotation, TypeDefInfo } from '@pezkuwi/types-create';
-import { isString, stringify } from '@pezkuwi/util';
-
-import { readTemplate } from './file.js';
-import { setImports } from './imports.js';
-
-interface ImportDef {
-  file: string;
-  types: string[];
-}
-
-interface This {
-  imports: TypeImports;
-  types: ImportDef[];
-}
-
-const NO_CODEC = ['Tuple', 'VecFixed'];
-const ON_CODEC = Object.keys(typesCodec);
-const ON_CODEC_TYPES = ['Codec', 'AnyJson', 'AnyFunction', 'AnyNumber', 'AnyString', 'AnyTuple', 'AnyU8a', 'ICompact', 'IEnum', 'IMap', 'INumber', 'IOption', 'IResult', 'ISet', 'IStruct', 'ITuple', 'IU8a', 'IVec', 'IMethod'];
-
-export const HEADER = (type: 'chain' | 'defs'): string => `// Auto-generated via \`yarn polkadot-types-from-${type}\`, do not edit\n/* eslint-disable */\n\n`;
-
-function extractImports ({ imports, types }: This): string[] {
-  const toplevel = [
-    ...Object.keys(imports.codecTypes),
-    ...Object.keys(imports.extrinsicTypes),
-    ...Object.keys(imports.genericTypes),
-    ...Object.keys(imports.metadataTypes),
-    ...Object.keys(imports.primitiveTypes)
-  ];
-
-  return [
-    {
-      file: '@pezkuwi/types',
-      types: toplevel.filter((n) =>
-        !NO_CODEC.includes(n) && !ON_CODEC.includes(n)
-      )
-    },
-    {
-      file: '@pezkuwi/types/lookup',
-      types: Object.keys(imports.lookupTypes)
-    },
-    {
-      file: '@pezkuwi/types/types',
-      types: Object.keys(imports.typesTypes).filter((n) =>
-        !ON_CODEC_TYPES.includes(n)
-      )
-    },
-    {
-      file: '@pezkuwi/types-codec',
-      types: toplevel.filter((n) =>
-        !NO_CODEC.includes(n) && ON_CODEC.includes(n)
-      )
-    },
-    {
-      file: '@pezkuwi/types-codec/types',
-      types: Object.keys(imports.typesTypes).filter((n) =>
-        ON_CODEC_TYPES.includes(n)
-      )
-    },
-    ...types
-  ]
-    .filter(({ types }) => types.length)
-    .sort(({ file }, b) => file.localeCompare(b.file))
-    .map(({ file, types }) => `import type { ${types.sort().join(', ')} } from '${file}';`);
-}
-
-Handlebars.registerPartial({
-  header: Handlebars.compile(readTemplate('header'))
-});
-
-Handlebars.registerHelper({
-  importsAll () {
-    return extractImports(this as unknown as This)
-      .join('\n');
-  },
-  importsPackage () {
-    return extractImports(this as unknown as This)
-      .filter((l) => !l.includes("from '."))
-      .join('\n  ');
-  },
-  importsRelative () {
-    return extractImports(this as unknown as This)
-      .filter((l) => l.includes("from '."))
-      .join('\n');
-  },
-  trim (options: { fn: (self: unknown) => string }) {
-    return options.fn(this).trim();
-  },
-  upper (options: { fn: (self: unknown) => string }) {
-    return options.fn(this).toUpperCase();
-  }
-});
-
-// helper to generate a `export interface <Name> extends <Base> {<Body>}
-/** @internal */
-export function exportInterface (lookupIndex = -1, name = '', base: string, body = '', withShortcut = false): string {
-  // * @description extends [[${base}]]
-  const doc = withShortcut
-    ? ''
-    : `/** @name ${name}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
-
-  return `${doc}${withShortcut ? '' : `export interface ${name} extends ${base} `}{${body.length ? '\n' : ''}${body}${withShortcut ? '  ' : ''}}`;
-}
-
-function singleParamNotation (registry: Registry, wrapper: string, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean): string {
-  const sub = (typeDef.sub as TypeDef);
-
-  setImports(definitions, imports, [wrapper, sub.lookupName]);
-
-  return paramsNotation(wrapper, sub.lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
-}
-
-function dualParamsNotation (registry: Registry, wrapper: string, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean): string {
-  const [a, b] = (typeDef.sub as TypeDef[]);
-
-  setImports(definitions, imports, [wrapper, a.lookupName, b.lookupName]);
-
-  return paramsNotation(wrapper, [
-    a.lookupName || formatType(registry, definitions, a.type, imports, withShortcut),
-    b.lookupName || formatType(registry, definitions, b.type, imports, withShortcut)
-  ]);
-}
-
-const formatters: Record<TypeDefInfo, (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => string> = {
-  [TypeDefInfo.Compact]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'Compact', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.DoNotConstruct]: (_registry: Registry, _typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
-    setImports(definitions, imports, ['DoNotConstruct']);
-
-    return 'DoNotConstruct';
-  },
-
-  [TypeDefInfo.Enum]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
-    if (typeDef.lookupName) {
-      return typeDef.lookupName;
-    }
-
-    throw new Error(`TypeDefInfo.Enum: Parameter formatting not implemented on ${stringify(typeDef)}`);
-  },
-
-  [TypeDefInfo.Int]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
-    throw new Error(`TypeDefInfo.Int: Parameter formatting not implemented on ${stringify(typeDef)}`);
-  },
-
-  [TypeDefInfo.UInt]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
-    throw new Error(`TypeDefInfo.UInt: Parameter formatting not implemented on ${stringify(typeDef)}`);
-  },
-
-  [TypeDefInfo.Null]: (_registry: Registry, _typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
-    setImports(definitions, imports, ['Null']);
-
-    return 'Null';
-  },
-
-  [TypeDefInfo.Option]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'Option', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.Plain]: (_registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, _withShortcut: boolean) => {
-    setImports(definitions, imports, [typeDef.type]);
-
-    return typeDef.type;
-  },
-
-  [TypeDefInfo.Range]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'Range', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.RangeInclusive]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'RangeInclusive', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.Set]: (_registry: Registry, typeDef: TypeDef, _definitions: Record<string, ModuleTypes>, _imports: TypeImports, _withShortcut: boolean) => {
-    throw new Error(`TypeDefInfo.Set: Parameter formatting not implemented on ${stringify(typeDef)}`);
-  },
-
-  [TypeDefInfo.Si]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return formatType(registry, definitions, registry.lookup.getTypeDef(typeDef.type as LookupString), imports, withShortcut);
-  },
-
-  [TypeDefInfo.Struct]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    if (typeDef.lookupName) {
-      return typeDef.lookupName;
-    }
-
-    const sub = typeDef.sub as TypeDef[];
-
-    setImports(definitions, imports, ['Struct', ...sub.map(({ lookupName }) => lookupName)]);
-
-    return `{${withShortcut ? ' ' : '\n'}${
-      sub.map(({ lookupName, name, type }, index) => [
-        name || `unknown${index}`,
-        lookupName || formatType(registry, definitions, type, imports, withShortcut)
-      ]).map(([k, t]) => `${withShortcut ? '' : '    readonly '}${k}: ${t};`).join(withShortcut ? ' ' : '\n')
-    }${withShortcut ? ' ' : '\n  '}} & Struct`;
-  },
-
-  [TypeDefInfo.Tuple]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    const sub = typeDef.sub as TypeDef[];
-
-    setImports(definitions, imports, ['ITuple', ...sub.map(({ lookupName }) => lookupName)]);
-
-    // `(a,b)` gets transformed into `ITuple<[a, b]>`
-    return paramsNotation('ITuple', `[${
-      sub.map(({ lookupName, type }) =>
-        lookupName || formatType(registry, definitions, type, imports, withShortcut)
-      ).join(', ')
-    }]`);
-  },
-
-  [TypeDefInfo.Vec]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.VecFixed]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    const sub = (typeDef.sub as TypeDef);
-
-    if (sub.type === 'u8') {
-      setImports(definitions, imports, ['U8aFixed']);
-
-      return 'U8aFixed';
-    }
-
-    return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.BTreeMap]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return dualParamsNotation(registry, 'BTreeMap', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.BTreeSet]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'BTreeSet', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.HashMap]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return dualParamsNotation(registry, 'HashMap', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.Linkage]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'Linkage', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.Result]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return dualParamsNotation(registry, 'Result', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.WrapperKeepOpaque]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'WrapperKeepOpaque', typeDef, definitions, imports, withShortcut);
-  },
-
-  [TypeDefInfo.WrapperOpaque]: (registry: Registry, typeDef: TypeDef, definitions: Record<string, ModuleTypes>, imports: TypeImports, withShortcut: boolean) => {
-    return singleParamNotation(registry, 'WrapperOpaque', typeDef, definitions, imports, withShortcut);
-  }
-};
-
-/**
- * Correctly format a given type
- */
-/** @internal */
-// eslint-disable-next-line @typescript-eslint/ban-types
-export function formatType (registry: Registry, definitions: Record<string, ModuleTypes>, type: AnyString | TypeDef, imports: TypeImports, withShortcut = false): string {
-  let typeDef: TypeDef;
-
-  if (isString(type)) {
-    const _type = type.toString();
-
-    // If type is "unorthodox" (i.e. `{ something: any }` for an Enum input or `[a | b | c, d | e | f]` for a Tuple's similar types),
-    // we return it as-is
-    if (withShortcut && /(^{.+:.+})|^\([^,]+\)|^\(.+\)\[\]|^\[.+\]/.exec(_type) && !/\[\w+;\w+\]/.exec(_type)) {
-      return _type;
-    }
-
-    typeDef = getTypeDef(type);
-  } else {
-    typeDef = type;
-  }
-
-  setImports(definitions, imports, [typeDef.lookupName || typeDef.type]);
-
-  return formatters[typeDef.info](registry, typeDef, definitions, imports, withShortcut);
-}