@pezkuwi/typegen 16.5.5 → 16.5.6

package/{src/templates → templates}/errors.hbs

@@ -2,13 +2,13 @@
 
 // import type lookup before we augment - in some environments
 // this is required to allow for ambient/previous definitions
-import '@polkadot/api-base/types/errors';
+import '@pezkuwi/api-base/types/errors';
 
 {{{ importsAll }}}
 
 export type __AugmentedError<ApiType extends ApiTypes> = AugmentedError<ApiType>;
 
-declare module '@polkadot/api-base/types/errors' {
+declare module '@pezkuwi/api-base/types/errors' {
   interface AugmentedErrors<ApiType extends ApiTypes> {
     {{#each modules}}
     {{{name}}}: {

package/{src/templates → templates}/events.hbs

@@ -2,13 +2,13 @@
 
 // import type lookup before we augment - in some environments
 // this is required to allow for ambient/previous definitions
-import '@polkadot/api-base/types/events';
+import '@pezkuwi/api-base/types/events';
 
 {{{ importsAll }}}
 
 export type __AugmentedEvent<ApiType extends ApiTypes> = AugmentedEvent<ApiType>;
 
-declare module '@polkadot/api-base/types/events' {
+declare module '@pezkuwi/api-base/types/events' {
   interface AugmentedEvents<ApiType extends ApiTypes> {
     {{#each modules}}
     {{{name}}}: {

package/{src/templates → templates}/interfaceRegistry.hbs

@@ -2,11 +2,11 @@
 
 // import type lookup before we augment - in some environments
 // this is required to allow for ambient/previous definitions
-import '@polkadot/types/types/registry';
+import '@pezkuwi/types/types/registry';
 
 {{{ importsAll }}}
 
-declare module '@polkadot/types/types/registry' {
+declare module '@pezkuwi/types/types/registry' {
   interface InterfaceTypes {
     {{#each items}}
     {{{this}}}: {{{this}}};

package/{src/templates → templates}/lookup/types.hbs

@@ -2,11 +2,11 @@
 
 // import type lookup before we augment - in some environments
 // this is required to allow for ambient/previous definitions
-import '@polkadot/types/lookup';
+import '@pezkuwi/types/lookup';
 
 {{{ importsAll }}}
 
-declare module '@polkadot/types/lookup' {
+declare module '@pezkuwi/types/lookup' {
   {{#each items}}
 {{{this}}}
 

package/{src/templates → templates}/query.hbs

@@ -2,14 +2,14 @@
 
 // import type lookup before we augment - in some environments
 // this is required to allow for ambient/previous definitions
-import '@polkadot/api-base/types/storage';
+import '@pezkuwi/api-base/types/storage';
 
 {{{ importsAll }}}
 
 export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
 export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
 
-declare module '@polkadot/api-base/types/storage' {
+declare module '@pezkuwi/api-base/types/storage' {
   interface AugmentedQueries<ApiType extends ApiTypes> {
     {{#each modules}}
     {{{name}}}: {

package/{src/templates → templates}/rpc.hbs

@@ -2,13 +2,13 @@
 
 // import type lookup before we augment - in some environments
 // this is required to allow for ambient/previous definitions
-import '@polkadot/rpc-core/types/jsonrpc';
+import '@pezkuwi/rpc-core/types/jsonrpc';
 
 {{{ importsAll }}}
 
 export type __AugmentedRpc = AugmentedRpc<() => unknown>;
 
-declare module '@polkadot/rpc-core/types/jsonrpc' {
+declare module '@pezkuwi/rpc-core/types/jsonrpc' {
   interface RpcInterface {
     {{#each modules}}
     {{{name}}}: {

package/{src/templates → templates}/tx.hbs

@@ -2,7 +2,7 @@
 
 // import type lookup before we augment - in some environments
 // this is required to allow for ambient/previous definitions
-import '@polkadot/api-base/types/submittable';
+import '@pezkuwi/api-base/types/submittable';
 
 {{{ importsAll }}}
 
@@ -10,7 +10,7 @@ export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
 export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
 export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;
 
-declare module '@polkadot/api-base/types/submittable' {
+declare module '@pezkuwi/api-base/types/submittable' {
   interface AugmentedSubmittables<ApiType extends ApiTypes> {
     {{#each modules}}
     {{{name}}}: {

package/util/assert.d.ts

@@ -0,0 +1,2 @@
+export declare function assertDir(path: string): string;
+export declare function assertFile(path: string): string;

package/util/assert.js

@@ -0,0 +1,10 @@
+import fs from 'node:fs';
+import { assert } from '@pezkuwi/util';
+export function assertDir(path) {
+    assert(fs.existsSync(path) && fs.lstatSync(path).isDirectory(), `${path} is not a directory`);
+    return path;
+}
+export function assertFile(path) {
+    assert(fs.existsSync(path) && fs.lstatSync(path).isFile(), `${path} is not a file`);
+    return path;
+}

package/util/derived.d.ts

@@ -0,0 +1,4 @@
+import type { Registry } from '@pezkuwi/types/types';
+import type { ModuleTypes, TypeImports } from './imports.js';
+/** @internal */
+export declare function getSimilarTypes(registry: Registry, definitions: Record<string, ModuleTypes>, _type: string, imports: TypeImports): string[];

package/util/derived.js

@@ -0,0 +1,125 @@
+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) {
+    return `${arr.map((c) => `'${c}'`).join(' | ')}`;
+}
+const voteConvictions = arrayToStrType(AllConvictions);
+/** @internal */
+export function getSimilarTypes(registry, definitions, _type, imports) {
+    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);
+        // 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.map(({ type }) => 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(registry);
+        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, 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(registry);
+        const obj = s.defKeys.map((key) => `${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);
+        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/util/docs.d.ts

@@ -0,0 +1 @@
+export declare const __TYPEGEN_DUMMY_DOCS = "DUMMY_DOCS";

package/util/docs.js

@@ -0,0 +1,6 @@
+import Handlebars from 'handlebars';
+import { readTemplate } from './file.js';
+Handlebars.registerPartial({
+    docs: Handlebars.compile(readTemplate('docs'))
+});
+export const __TYPEGEN_DUMMY_DOCS = 'DUMMY_DOCS';

package/util/file.d.ts

@@ -0,0 +1,2 @@
+export declare function writeFile(dest: string, generator: () => string, noLog?: boolean): void;
+export declare function readTemplate(template: string): string;

package/util/file.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { packageInfo } from '../packageInfo.js';
+export function writeFile(dest, generator, noLog) {
+    !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) {
+    // 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/util/formatting.d.ts

@@ -0,0 +1,11 @@
+import type { AnyString, Registry } from '@pezkuwi/types/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { ModuleTypes, TypeImports } from './imports.js';
+export declare const HEADER: (type: "chain" | "defs") => string;
+/** @internal */
+export declare function exportInterface(lookupIndex: number | undefined, name: string | undefined, base: string, body?: string, withShortcut?: boolean): string;
+/**
+ * Correctly format a given type
+ */
+/** @internal */
+export declare function formatType(registry: Registry, definitions: Record<string, ModuleTypes>, type: AnyString | TypeDef, imports: TypeImports, withShortcut?: boolean): string;

package/util/formatting.js

@@ -0,0 +1,230 @@
+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';
+function rebrandTypeName(typeName) {
+    return typeName
+        // Main projects
+        .replace(/Polkadot/g, 'Pezkuwi')
+        .replace(/Substrate/g, 'Bizinikiwi')
+        .replace(/Cumulus/g, 'Pezcumulus')
+        // Networks
+        .replace(/Kusama/g, 'Dicle')
+        .replace(/Westend/g, 'Zagros')
+        .replace(/Rococo/g, 'Pezkuwichain')
+        // Chain types
+        .replace(/Parachain/g, 'Teyrchain')
+        // Module prefixes (in PascalCase type names)
+        .replace(/Frame(?=[A-Z])/g, 'Pezframe')
+        .replace(/Pallet(?=[A-Z])/g, 'Pezpallet')
+        // Primitives prefixes (sp_ becomes Sp in type names)
+        .replace(/^Sp(?=[A-Z])/g, 'Pezsp')
+        .replace(/([^a-zA-Z])Sp(?=[A-Z])/g, '$1Pezsp')
+        // Client prefixes (sc_ becomes Sc in type names)
+        .replace(/^Sc(?=[A-Z])/g, 'Pezsc')
+        .replace(/([^a-zA-Z])Sc(?=[A-Z])/g, '$1Pezsc');
+}
+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) => `// Auto-generated via \`yarn pezkuwi-types-from-${type}\`, do not edit\n/* eslint-disable */\n\n`;
+function extractImports({ imports, types }) {
+    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)
+            .join('\n');
+    },
+    importsPackage() {
+        return extractImports(this)
+            .filter((l) => !l.includes("from '."))
+            .join('\n  ');
+    },
+    importsRelative() {
+        return extractImports(this)
+            .filter((l) => l.includes("from '."))
+            .join('\n');
+    },
+    trim(options) {
+        return options.fn(this).trim();
+    },
+    upper(options) {
+        return options.fn(this).toUpperCase();
+    }
+});
+/** @internal */
+export function exportInterface(lookupIndex = -1, name = '', base, body = '', withShortcut = false) {
+    // * @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, wrapper, typeDef, definitions, imports, withShortcut) {
+    const sub = typeDef.sub;
+    const lookupName = rebrandTypeName(sub.lookupName || '');
+    setImports(definitions, imports, [wrapper, lookupName]);
+    return paramsNotation(wrapper, lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
+}
+function dualParamsNotation(registry, wrapper, typeDef, definitions, imports, withShortcut) {
+    const [a, b] = typeDef.sub;
+    const aLookupName = rebrandTypeName(a.lookupName || '');
+    const bLookupName = rebrandTypeName(b.lookupName || '');
+    setImports(definitions, imports, [wrapper, aLookupName, bLookupName]);
+    return paramsNotation(wrapper, [
+        aLookupName || formatType(registry, definitions, a.type, imports, withShortcut),
+        bLookupName || formatType(registry, definitions, b.type, imports, withShortcut)
+    ]);
+}
+const formatters = {
+    [TypeDefInfo.Compact]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Compact', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.DoNotConstruct]: (_registry, _typeDef, definitions, imports, _withShortcut) => {
+        setImports(definitions, imports, ['DoNotConstruct']);
+        return 'DoNotConstruct';
+    },
+    [TypeDefInfo.Enum]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
+        if (typeDef.lookupName) {
+            return rebrandTypeName(typeDef.lookupName);
+        }
+        throw new Error(`TypeDefInfo.Enum: Parameter formatting not implemented on ${stringify(typeDef)}`);
+    },
+    [TypeDefInfo.Int]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
+        throw new Error(`TypeDefInfo.Int: Parameter formatting not implemented on ${stringify(typeDef)}`);
+    },
+    [TypeDefInfo.UInt]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
+        throw new Error(`TypeDefInfo.UInt: Parameter formatting not implemented on ${stringify(typeDef)}`);
+    },
+    [TypeDefInfo.Null]: (_registry, _typeDef, definitions, imports, _withShortcut) => {
+        setImports(definitions, imports, ['Null']);
+        return 'Null';
+    },
+    [TypeDefInfo.Option]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Option', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.Plain]: (_registry, typeDef, definitions, imports, _withShortcut) => {
+        setImports(definitions, imports, [rebrandTypeName(typeDef.type)]);
+        return rebrandTypeName(typeDef.type);
+    },
+    [TypeDefInfo.Range]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Range', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.RangeInclusive]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'RangeInclusive', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.Set]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
+        throw new Error(`TypeDefInfo.Set: Parameter formatting not implemented on ${stringify(typeDef)}`);
+    },
+    [TypeDefInfo.Si]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return formatType(registry, definitions, registry.lookup.getTypeDef(typeDef.type), imports, withShortcut);
+    },
+    [TypeDefInfo.Struct]: (registry, typeDef, definitions, imports, withShortcut) => {
+        if (typeDef.lookupName) {
+            return rebrandTypeName(typeDef.lookupName);
+        }
+        const sub = typeDef.sub;
+        setImports(definitions, imports, ['Struct', ...sub.map(({ lookupName }) => rebrandTypeName(lookupName || ''))]);
+        return `{${withShortcut ? ' ' : '\n'}${sub.map(({ lookupName, name, type }, index) => [
+            name || `unknown${index}`,
+            rebrandTypeName(lookupName || '') || formatType(registry, definitions, type, imports, withShortcut)
+        ]).map(([k, t]) => `${withShortcut ? '' : '    readonly '}${k}: ${t};`).join(withShortcut ? ' ' : '\n')}${withShortcut ? ' ' : '\n  '}} & Struct`;
+    },
+    [TypeDefInfo.Tuple]: (registry, typeDef, definitions, imports, withShortcut) => {
+        const sub = typeDef.sub;
+        setImports(definitions, imports, ['ITuple', ...sub.map(({ lookupName }) => rebrandTypeName(lookupName || ''))]);
+        // `(a,b)` gets transformed into `ITuple<[a, b]>`
+        return paramsNotation('ITuple', `[${sub.map(({ lookupName, type }) => rebrandTypeName(lookupName || '') || formatType(registry, definitions, type, imports, withShortcut)).join(', ')}]`);
+    },
+    [TypeDefInfo.Vec]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.VecFixed]: (registry, typeDef, definitions, imports, withShortcut) => {
+        const sub = typeDef.sub;
+        if (sub.type === 'u8') {
+            setImports(definitions, imports, ['U8aFixed']);
+            return 'U8aFixed';
+        }
+        return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.BTreeMap]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return dualParamsNotation(registry, 'BTreeMap', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.BTreeSet]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'BTreeSet', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.HashMap]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return dualParamsNotation(registry, 'HashMap', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.Linkage]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'Linkage', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.Result]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return dualParamsNotation(registry, 'Result', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'WrapperKeepOpaque', typeDef, definitions, imports, withShortcut);
+    },
+    [TypeDefInfo.WrapperOpaque]: (registry, typeDef, definitions, imports, withShortcut) => {
+        return singleParamNotation(registry, 'WrapperOpaque', typeDef, definitions, imports, withShortcut);
+    }
+};
+/**
+ * Correctly format a given type
+ */
+/** @internal */
+export function formatType(registry, definitions, type, imports, withShortcut = false) {
+    let 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 rebrandTypeName(_type);
+        }
+        typeDef = getTypeDef(type);
+    }
+    else {
+        typeDef = type;
+    }
+    setImports(definitions, imports, [rebrandTypeName(typeDef.lookupName || typeDef.type)]);
+    return rebrandTypeName(formatters[typeDef.info](registry, typeDef, definitions, imports, withShortcut));
+}

package/util/imports.d.ts

@@ -0,0 +1,23 @@
+export interface ModuleTypes {
+    types: Record<string, unknown>;
+}
+type TypeExist = Record<string, boolean>;
+type TypeExistMap = Record<string, TypeExist>;
+export interface TypeImports {
+    codecTypes: TypeExist;
+    extrinsicTypes: TypeExist;
+    genericTypes: TypeExist;
+    ignoredTypes: string[];
+    localTypes: TypeExistMap;
+    lookupTypes: TypeExistMap;
+    primitiveTypes: TypeExist;
+    metadataTypes: TypeExist;
+    typesTypes: TypeExist;
+    definitions: Record<string, ModuleTypes>;
+    typeToModule: Record<string, string>;
+}
+/** @internal */
+export declare function setImports(allDefs: Record<string, ModuleTypes>, imports: TypeImports, types: (string | null | undefined)[]): void;
+/** @internal */
+export declare function createImports(importDefinitions: Record<string, Record<string, ModuleTypes>>, { types }?: ModuleTypes): TypeImports;
+export {};