@pezkuwi/typegen 16.5.18 → 16.5.31

package/build-tsc-esm/generate/runtime.js

@@ -1,228 +0,0 @@
-import Handlebars from 'handlebars';
-import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
-import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
-import { objectSpread, stringCamelCase } from '@pezkuwi/util';
-import { blake2AsHex } from '@pezkuwi/util-crypto';
-import { createImports, formatType, getSimilarTypes, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
-import { getDeprecationNotice } from './types.js';
-const generateCallsTypesTemplate = Handlebars.compile(readTemplate('calls'));
-const aliases = {
-    AssetHubZagrosRuntimeRuntimeCall: 'RuntimeCall',
-    AssetHubPezkuwiRuntimeRuntimeCall: 'RuntimeCall',
-    AssetHubDicleRuntimeOriginCaller: 'OriginCaller',
-    AssetHubDicleRuntimeRuntimeCall: 'RuntimeCall',
-    DicleRuntimeConstantsProxyProxyType: 'ProxyType',
-    KitchensinkRuntimeRuntimeCall: 'RuntimeCall',
-    KitchensinkRuntimeRuntimeParametersKey: 'RuntimeParametersKey',
-    OpaqueValue: 'Bytes',
-    PezkuwiTeyrchainPrimitivesPrimitivesId: 'ParaId',
-    PezkuwiTeyrchainPrimitivesPrimitivesValidationCodeHash: 'ValidationCodeHash',
-    PezkuwiPrimitivesV7SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-    PezkuwiPrimitivesV8SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-    PezkuwiRuntimeRuntimeCall: 'RuntimeCall',
-    PrimitiveTypesH160: 'H160',
-    PrimitiveTypesH256: 'H256',
-    PrimitiveTypesU256: 'U256',
-    PezspConsensusBabeOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
-    PezspConsensusSlotsSlot: 'Slot',
-    PezspConsensusSlotsSlotDuration: 'SlotDuration',
-    PezspCoreCryptoAccountId32: 'AccountId32',
-    PezspCoreOpaqueMetadata: 'OpaqueMetadata',
-    PezspRuntimeOpaqueValue: 'Bytes',
-    PezspRuntimeUncheckedExtrinsic: 'Extrinsic',
-    StagingDicleRuntimeOriginCaller: 'OriginCaller',
-    StagingDicleRuntimeRuntimeCall: 'RuntimeCall',
-    StagingDicleRuntimeRuntimeParameters: 'RuntimeParameters',
-    StagingDicleRuntimeRuntimeParametersKey: 'RuntimeParametersKey',
-    StagingZagrosRuntimeRuntimeCall: 'RuntimeCall'
-};
-const getTypesViaAlias = (registry, id) => {
-    const rawTypeName = registry.lookup.getName(id) || registry.lookup.getTypeDef(id).type;
-    const typeName = rebrandTypeName(rawTypeName);
-    if (aliases[typeName]) {
-        return aliases[typeName];
-    }
-    return typeName;
-};
-/** @internal */
-function getMethods(registry, methods) {
-    const result = {};
-    methods.forEach((m) => {
-        const { deprecationInfo, docs, inputs, name, output } = m;
-        let description = docs.map((d) => d.toString()).join();
-        if (!deprecationInfo.isNotDeprecated) {
-            const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name));
-            const notice = description.length ? `\n * ${deprecationNotice}` : ` * ${deprecationNotice}`;
-            description += notice;
-        }
-        result[name.toString()] = {
-            description,
-            params: inputs.map(({ name, type }) => {
-                return { name: name.toString(), type: getTypesViaAlias(registry, type) };
-            }),
-            type: getTypesViaAlias(registry, output)
-        };
-    });
-    return result;
-}
-/** @internal */
-function getRuntimeDefViaMetadata(registry) {
-    const result = {};
-    const { apis } = registry.metadata;
-    for (let i = 0, count = apis.length; i < count; i++) {
-        const { methods, name } = apis[i];
-        result[name.toString()] = [{
-                methods: getMethods(registry, methods),
-                // We set the version to 0 here since it will not be relevant when we are grabbing the runtime apis
-                // from the Metadata.
-                version: 0
-            }];
-    }
-    return Object.entries(result);
-}
-/** @internal */
-function getDefs(apis, defs, registry) {
-    const named = {};
-    const all = Object.values(defs);
-    const isApiInMetadata = registry.metadata.apis.length > 0;
-    if (isApiInMetadata) {
-        const sections = getRuntimeDefViaMetadata(registry);
-        for (let j = 0, jcount = sections.length; j < jcount; j++) {
-            const [_section, secs] = sections[j];
-            const sec = secs[0];
-            const sectionHash = blake2AsHex(_section, 64);
-            const section = stringCamelCase(_section);
-            const methods = Object.entries(sec.methods);
-            if (!named[section]) {
-                named[section] = {};
-            }
-            for (let m = 0, mcount = methods.length; m < mcount; m++) {
-                const [_method, def] = methods[m];
-                const method = stringCamelCase(_method);
-                named[section][method] = objectSpread({ method, name: `${_section}_${_method}`, section, sectionHash }, def);
-            }
-        }
-    }
-    else {
-        for (let j = 0, jcount = all.length; j < jcount; j++) {
-            const set = all[j].runtime;
-            if (set) {
-                const sections = Object.entries(set);
-                for (let i = 0, scount = sections.length; i < scount; i++) {
-                    const [_section, sec] = sections[i];
-                    const sectionHash = blake2AsHex(_section, 64);
-                    const api = apis?.find(([h]) => h === sectionHash);
-                    if (api) {
-                        const ver = sec.find(({ version }) => version === api[1]);
-                        if (ver) {
-                            const methods = Object.entries(ver.methods);
-                            const mcount = methods.length;
-                            if (mcount) {
-                                const section = stringCamelCase(_section);
-                                if (!named[section]) {
-                                    named[section] = {};
-                                }
-                                for (let m = 0; m < mcount; m++) {
-                                    const [_method, def] = methods[m];
-                                    const method = stringCamelCase(_method);
-                                    named[section][method] = objectSpread({ method, name: `${_section}_${method}`, section, sectionHash, version: ver.version }, def);
-                                }
-                            }
-                        }
-                        else {
-                            console.warn(`Unable to find matching version for runtime ${_section}, expected ${api[1]}`);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    return named;
-}
-/** @internal */
-export function generateCallTypes(registry, meta, dest, extraTypes, isStrict, customLookupDefinitions) {
-    writeFile(dest, () => {
-        const allTypes = {
-            '@pezkuwi/types-augment': {
-                lookup: {
-                    ...lookupDefinitions,
-                    ...customLookupDefinitions
-                }
-            },
-            '@pezkuwi/types/interfaces': defaultDefs,
-            ...extraTypes
-        };
-        const imports = createImports(allTypes);
-        // find the system.Version in metadata
-        let apis = null;
-        const sysp = meta.asLatest.pallets.find(({ name }) => name.eq('System'));
-        if (sysp) {
-            const verc = sysp.constants.find(({ name }) => name.eq('Version'));
-            if (verc) {
-                apis = registry.createType('RuntimeVersion', verc.value).apis.map(([k, v]) => [k.toHex(), v.toNumber()]);
-            }
-            else {
-                console.error('Unable to find System.Version pallet, skipping API extraction');
-            }
-        }
-        else {
-            console.error('Unable to find System pallet, skipping API extraction');
-        }
-        const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-            return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-        }, {});
-        const definitions = getDefs(apis, imports.definitions, registry);
-        const callKeys = Object.keys(definitions);
-        const modules = callKeys.map((section) => {
-            const calls = definitions[section];
-            const allMethods = Object.keys(calls).sort().map((methodName) => {
-                const def = calls[methodName];
-                setImports(allDefs, imports, [def.type]);
-                const args = def.params.map((param) => {
-                    const similarTypes = getSimilarTypes(registry, imports.definitions, param.type, imports);
-                    setImports(allDefs, imports, [param.type, ...similarTypes]);
-                    return `${param.name}: ${similarTypes.join(' | ')}`;
-                });
-                return {
-                    args: args.join(', '),
-                    docs: [def.description],
-                    name: methodName,
-                    sectionHash: def.sectionHash,
-                    sectionName: def.section,
-                    sectionVersion: def.version,
-                    type: formatType(registry, allDefs, def.type, imports)
-                };
-            }).sort((a, b) => a.name.localeCompare(b.name));
-            return {
-                items: allMethods,
-                name: section || 'unknown',
-                sectionHash: allMethods.length && allMethods[0].sectionHash,
-                sectionName: allMethods.length && allMethods[0].sectionName,
-                sectionVersion: allMethods.length && allMethods[0].sectionVersion
-            };
-        }).filter(({ items }) => items.length).sort((a, b) => a.name.localeCompare(b.name));
-        if (modules.length) {
-            imports.typesTypes['Observable'] = true;
-        }
-        return generateCallsTypesTemplate({
-            headerType: 'chain',
-            imports,
-            isStrict,
-            modules,
-            types: [
-                ...Object.keys(imports.localTypes).sort().map((packagePath) => ({
-                    file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-                    types: Object.keys(imports.localTypes[packagePath])
-                })),
-                {
-                    file: '@pezkuwi/api-base/types',
-                    types: ['ApiTypes', 'AugmentedCall', 'DecoratedCallBase']
-                }
-            ]
-        });
-    });
-}
-export function generateDefaultRuntime(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
-    const { metadata, registry } = initMeta(data, extraTypes);
-    generateCallTypes(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

package/build-tsc-esm/generate/tsDef.js

@@ -1,246 +0,0 @@
-import Handlebars from 'handlebars';
-import path from 'node:path';
-import { TypeRegistry } from '@pezkuwi/types/create';
-import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
-import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
-import { assert, isString, stringify, stringPascalCase } from '@pezkuwi/util';
-import { createImports, exportInterface, formatType, readTemplate, setImports, writeFile } from '../util/index.js';
-const generateTsDefIndexTemplate = Handlebars.compile(readTemplate('tsDef/index'));
-const generateTsDefModuleTypesTemplate = Handlebars.compile(readTemplate('tsDef/moduleTypes'));
-const generateTsDefTypesTemplate = Handlebars.compile(readTemplate('tsDef/types'));
-/** @internal */
-export function createGetter(definitions, name = '', type, imports) {
-    setImports(definitions, imports, [type]);
-    return `  readonly ${name}: ${type};\n`;
-}
-/** @internal */
-function errorUnhandled(_, _definitions, def, _imports) {
-    throw new Error(`Generate: ${def.name || ''}: Unhandled type ${TypeDefInfo[def.info]}`);
-}
-/** @internal */
-function tsExport(registry, definitions, def, imports) {
-    return exportInterface(def.lookupIndex, def.name, formatType(registry, definitions, def, imports, false));
-}
-/** @internal */
-function tsEnum(registry, definitions, { lookupIndex, name: enumName, sub }, imports, withShortcut = false) {
-    setImports(definitions, imports, ['Enum']);
-    const indent = withShortcut ? '  ' : '';
-    const named = sub.filter(({ name }) => !!name && !name.startsWith('__Unused'));
-    const keys = named.map((def) => {
-        const { info, lookupName, name = '', sub, type } = def;
-        const getter = stringPascalCase(name.replace(' ', '_'));
-        const isComplex = [TypeDefInfo.Option, TypeDefInfo.Range, TypeDefInfo.RangeInclusive, TypeDefInfo.Result, TypeDefInfo.Struct, TypeDefInfo.Tuple, TypeDefInfo.Vec, TypeDefInfo.VecFixed].includes(info);
-        let extractedLookupName;
-        // When the parent type does not have a lookupName, and the sub type is the same
-        // type as the parent we can take the lookupName from the sub.
-        // This is specific to `StagingXcmV4Junction`.
-        // see: https://github.com/pezkuwichain/pezkuwi-api/pull/5812
-        if (sub && !Array.isArray(sub) && type.includes(`${sub.type};`)) {
-            if (sub.lookupName === 'StagingXcmV4Junction') {
-                extractedLookupName = sub.lookupName;
-            }
-            else if (sub.lookupName === 'StagingXcmV5Junction') {
-                extractedLookupName = `Vec<${sub.lookupName}>`;
-            }
-        }
-        const asGetter = type === 'Null' || info === TypeDefInfo.DoNotConstruct
-            ? ''
-            : createGetter(definitions, `as${getter}`, lookupName || extractedLookupName || (isComplex ? formatType(registry, definitions, info === TypeDefInfo.Struct ? def : type, imports, withShortcut) : type), imports);
-        const isGetter = info === TypeDefInfo.DoNotConstruct
-            ? ''
-            : createGetter(definitions, `is${getter}`, 'boolean', imports);
-        switch (info) {
-            case TypeDefInfo.Compact:
-            case TypeDefInfo.Plain:
-            case TypeDefInfo.Range:
-            case TypeDefInfo.RangeInclusive:
-            case TypeDefInfo.Result:
-            case TypeDefInfo.Si:
-            case TypeDefInfo.Struct:
-            case TypeDefInfo.Tuple:
-            case TypeDefInfo.Vec:
-            case TypeDefInfo.BTreeMap:
-            case TypeDefInfo.BTreeSet:
-            case TypeDefInfo.Option:
-            case TypeDefInfo.VecFixed:
-            case TypeDefInfo.WrapperKeepOpaque:
-            case TypeDefInfo.WrapperOpaque:
-                return `${indent}${isGetter}${indent}${asGetter}`;
-            case TypeDefInfo.DoNotConstruct:
-            case TypeDefInfo.Null:
-                return `${indent}${isGetter}`;
-            default:
-                throw new Error(`Enum: ${enumName || 'undefined'}: Unhandled type ${TypeDefInfo[info]}, ${stringify(def)}`);
-        }
-    });
-    return exportInterface(lookupIndex, enumName, 'Enum', `${keys.join('')}  ${indent}readonly type: ${named.map(({ name = '' }) => `'${stringPascalCase(name.replace(' ', '_'))}'`).join(' | ')};\n`, withShortcut);
-}
-function tsInt(_, definitions, def, imports, type = 'Int') {
-    setImports(definitions, imports, [type]);
-    return exportInterface(def.lookupIndex, def.name, type);
-}
-/** @internal */
-function tsNull(_registry, definitions, { lookupIndex = -1, name }, imports) {
-    setImports(definitions, imports, ['Null']);
-    // * @description extends [[${base}]]
-    const doc = `/** @name ${name || ''}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
-    return `${doc}export type ${name || ''} = Null;`;
-}
-/** @internal */
-function tsResultGetter(registry, definitions, resultName = '', getter, def, imports) {
-    const { info, lookupName, type } = def;
-    const asGetter = type === 'Null'
-        ? ''
-        : createGetter(definitions, `as${getter}`, lookupName || (info === TypeDefInfo.Tuple ? formatType(registry, definitions, def, imports, false) : type), imports);
-    const isGetter = createGetter(definitions, `is${getter}`, 'boolean', imports);
-    switch (info) {
-        case TypeDefInfo.Option:
-        case TypeDefInfo.Plain:
-        case TypeDefInfo.Si:
-        case TypeDefInfo.Tuple:
-        case TypeDefInfo.Vec:
-        case TypeDefInfo.BTreeMap:
-        case TypeDefInfo.BTreeSet:
-        case TypeDefInfo.WrapperKeepOpaque:
-        case TypeDefInfo.WrapperOpaque:
-            return `${isGetter}${asGetter}`;
-        case TypeDefInfo.Null:
-            return `${isGetter}`;
-        default:
-            throw new Error(`Result: ${resultName}: Unhandled type ${TypeDefInfo[info]}, ${stringify(def)}`);
-    }
-}
-/** @internal */
-function tsResult(registry, definitions, def, imports) {
-    const [okDef, errorDef] = def.sub;
-    const inner = [
-        tsResultGetter(registry, definitions, def.name, 'Err', errorDef, imports),
-        tsResultGetter(registry, definitions, def.name, 'Ok', okDef, imports)
-    ].join('');
-    setImports(definitions, imports, [def.type]);
-    const fmtType = def.lookupName && def.name !== def.lookupName
-        ? def.lookupName
-        : formatType(registry, definitions, def, imports, false);
-    return exportInterface(def.lookupIndex, def.name, fmtType, inner);
-}
-/** @internal */
-function tsSi(_registry, _definitions, typeDef, _imports) {
-    // FIXME
-    return `// SI: ${stringify(typeDef)}`;
-}
-/** @internal */
-function tsSet(_, definitions, { lookupIndex, name: setName, sub }, imports) {
-    setImports(definitions, imports, ['Set']);
-    const types = sub.map(({ name }) => {
-        assert(name, 'Invalid TypeDef found, no name specified');
-        return createGetter(definitions, `is${name}`, 'boolean', imports);
-    });
-    return exportInterface(lookupIndex, setName, 'Set', types.join(''));
-}
-/** @internal */
-function tsStruct(registry, definitions, { lookupIndex, name: structName, sub }, imports) {
-    setImports(definitions, imports, ['Struct']);
-    const keys = sub.map((def) => {
-        const fmtType = def.lookupName && def.name !== def.lookupName
-            ? def.lookupName
-            : def.info === TypeDefInfo.Enum
-                ? `${tsEnum(registry, definitions, def, imports, true)} & Enum`
-                : formatType(registry, definitions, def, imports, false);
-        return createGetter(definitions, def.name, fmtType, imports);
-    });
-    return exportInterface(lookupIndex, structName, 'Struct', keys.join(''));
-}
-/** @internal */
-function tsUInt(registry, definitions, def, imports) {
-    return tsInt(registry, definitions, def, imports, 'UInt');
-}
-/** @internal */
-function tsVec(registry, definitions, def, imports) {
-    const type = def.sub.type;
-    if (type === 'u8') {
-        if (def.info === TypeDefInfo.VecFixed) {
-            setImports(definitions, imports, ['U8aFixed']);
-            return exportInterface(def.lookupIndex, def.name, 'U8aFixed');
-        }
-        else {
-            setImports(definitions, imports, ['Bytes']);
-            return exportInterface(def.lookupIndex, def.name, 'Bytes');
-        }
-    }
-    const fmtType = def.lookupName && def.name !== def.lookupName
-        ? def.lookupName
-        : formatType(registry, definitions, def, imports, false);
-    return exportInterface(def.lookupIndex, def.name, fmtType);
-}
-export const typeEncoders = {
-    [TypeDefInfo.BTreeMap]: tsExport,
-    [TypeDefInfo.BTreeSet]: tsExport,
-    [TypeDefInfo.Compact]: tsExport,
-    [TypeDefInfo.DoNotConstruct]: tsExport,
-    [TypeDefInfo.Enum]: tsEnum,
-    [TypeDefInfo.HashMap]: tsExport,
-    [TypeDefInfo.Int]: tsInt,
-    [TypeDefInfo.Linkage]: errorUnhandled,
-    [TypeDefInfo.Null]: tsNull,
-    [TypeDefInfo.Option]: tsExport,
-    [TypeDefInfo.Plain]: tsExport,
-    [TypeDefInfo.Range]: tsExport,
-    [TypeDefInfo.RangeInclusive]: tsExport,
-    [TypeDefInfo.Result]: tsResult,
-    [TypeDefInfo.Set]: tsSet,
-    [TypeDefInfo.Si]: tsSi,
-    [TypeDefInfo.Struct]: tsStruct,
-    [TypeDefInfo.Tuple]: tsExport,
-    [TypeDefInfo.UInt]: tsUInt,
-    [TypeDefInfo.Vec]: tsVec,
-    [TypeDefInfo.VecFixed]: tsVec,
-    [TypeDefInfo.WrapperKeepOpaque]: tsExport,
-    [TypeDefInfo.WrapperOpaque]: tsExport
-};
-/** @internal */
-function generateInterfaces(registry, definitions, { types }, imports) {
-    return Object.entries(types).map(([name, type]) => {
-        const def = getTypeDef(isString(type) ? type : stringify(type), { name });
-        return [name, typeEncoders[def.info](registry, definitions, def, imports)];
-    });
-}
-/** @internal */
-export function generateTsDefFor(registry, importDefinitions, defName, { types }, outputDir) {
-    const imports = { ...createImports(importDefinitions, { types }), interfaces: [] };
-    const definitions = imports.definitions;
-    const interfaces = generateInterfaces(registry, definitions, { types }, imports);
-    const items = interfaces.sort((a, b) => a[0].localeCompare(b[0])).map(([, definition]) => definition);
-    writeFile(path.join(outputDir, defName, 'types.ts'), () => generateTsDefModuleTypesTemplate({
-        headerType: 'defs',
-        imports,
-        items,
-        name: defName,
-        types: [
-            ...Object.keys(imports.localTypes).sort().map((packagePath) => ({
-                file: packagePath.replace('@pezkuwi/types/augment', '@pezkuwi/types'),
-                types: Object.keys(imports.localTypes[packagePath])
-            }))
-        ]
-    }), true);
-    writeFile(path.join(outputDir, defName, 'index.ts'), () => generateTsDefIndexTemplate({ headerType: 'defs' }), true);
-}
-/** @internal */
-export function generateTsDef(importDefinitions, outputDir, generatingPackage) {
-    const registry = new TypeRegistry();
-    writeFile(path.join(outputDir, 'types.ts'), () => {
-        const definitions = importDefinitions[generatingPackage];
-        Object.entries(definitions).forEach(([defName, obj]) => {
-            console.log(`\tExtracting interfaces for ${defName}`);
-            generateTsDefFor(registry, importDefinitions, defName, obj, outputDir);
-        });
-        return generateTsDefTypesTemplate({
-            headerType: 'defs',
-            items: Object.keys(definitions)
-        });
-    });
-    writeFile(path.join(outputDir, 'index.ts'), () => generateTsDefIndexTemplate({ headerType: 'defs' }), true);
-}
-/** @internal */
-export function generateDefaultTsDef() {
-    generateTsDef({ '@pezkuwi/types/interfaces': defaultDefinitions }, 'packages/types/src/interfaces', '@pezkuwi/types/interfaces');
-}

package/build-tsc-esm/generate/tx.js

@@ -1,117 +0,0 @@
-import Handlebars from 'handlebars';
-import * as defaultDefs from '@pezkuwi/types/interfaces/definitions';
-import lookupDefinitions from '@pezkuwi/types-augment/lookup/definitions';
-import { stringCamelCase } from '@pezkuwi/util';
-import { compareName, createImports, formatType, getSimilarTypes, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
-import { ignoreUnusedLookups } from './lookup.js';
-import { getDeprecationNotice } from './types.js';
-const MAPPED_NAMES = {
-    class: 'clazz',
-    new: 'updated'
-};
-const generateForMetaTemplate = Handlebars.compile(readTemplate('tx'));
-function mapName(_name) {
-    const name = stringCamelCase(_name);
-    return MAPPED_NAMES[name] || name;
-}
-/** @internal */
-function generateForMeta(registry, meta, dest, extraTypes, isStrict, customLookupDefinitions) {
-    writeFile(dest, () => {
-        const allTypes = {
-            '@pezkuwi/types-augment': {
-                lookup: {
-                    ...lookupDefinitions,
-                    ...customLookupDefinitions
-                }
-            },
-            '@pezkuwi/types/interfaces': defaultDefs,
-            ...extraTypes
-        };
-        const imports = createImports(allTypes);
-        const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
-            return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
-        }, {});
-        const { lookup, pallets } = meta.asLatest;
-        const usedTypes = new Set([]);
-        const modules = pallets
-            .sort(compareName)
-            .filter(({ calls }) => calls.isSome)
-            .map((data) => {
-            const name = data.name;
-            const calls = data.calls.unwrap();
-            const deprecationInfo = calls.deprecationInfo.toJSON();
-            setImports(allDefs, imports, ['SubmittableExtrinsic']);
-            const sectionName = stringCamelCase(name);
-            const items = lookup.getSiType(calls.type).def.asVariant.variants
-                .map(({ docs, fields, index, name }) => {
-                const rawStatus = deprecationInfo?.[index.toNumber()];
-                if (rawStatus) {
-                    const deprecationVariantInfo = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
-                    const deprecationNotice = getDeprecationNotice(deprecationVariantInfo, name.toString(), 'Call');
-                    const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
-                    docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
-                }
-                const typesInfo = fields.map(({ name, type, typeName }, index) => {
-                    const typeDef = registry.lookup.getTypeDef(type);
-                    return [
-                        name.isSome
-                            ? mapName(name.unwrap())
-                            : `param${index}`,
-                        rebrandTypeName(typeName.isSome
-                            ? typeName.toString()
-                            : typeDef.type),
-                        rebrandTypeName(typeDef.isFromSi
-                            ? typeDef.type
-                            : typeDef.lookupName || typeDef.type)
-                    ];
-                });
-                const params = typesInfo
-                    .map(([name, , typeStr]) => {
-                    const similarTypes = getSimilarTypes(registry, allDefs, typeStr, imports);
-                    setImports(allDefs, imports, [typeStr, ...similarTypes]);
-                    // Add the type to the list of used types
-                    if (!(imports.primitiveTypes[typeStr])) {
-                        usedTypes.add(typeStr);
-                    }
-                    return `${name}: ${similarTypes.join(' | ')}`;
-                })
-                    .join(', ');
-                return {
-                    args: typesInfo.map(([, , typeStr]) => formatType(registry, allDefs, typeStr, imports)).join(', '),
-                    docs,
-                    name: stringCamelCase(name),
-                    params
-                };
-            })
-                .sort(compareName);
-            return {
-                items,
-                name: sectionName
-            };
-        })
-            .sort(compareName);
-        // filter out the unused lookup types from imports
-        ignoreUnusedLookups([...usedTypes], imports);
-        return generateForMetaTemplate({
-            headerType: 'chain',
-            imports,
-            isStrict,
-            modules,
-            types: [
-                ...Object.keys(imports.localTypes).sort().map((packagePath) => ({
-                    file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-                    types: Object.keys(imports.localTypes[packagePath])
-                })),
-                {
-                    file: '@pezkuwi/api-base/types',
-                    types: ['ApiTypes', 'AugmentedSubmittable', 'SubmittableExtrinsic', 'SubmittableExtrinsicFunction']
-                }
-            ]
-        });
-    });
-}
-/** @internal */
-export function generateDefaultTx(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
-    const { metadata, registry } = initMeta(data, extraTypes);
-    return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

package/build-tsc-esm/generate/types.js

@@ -1,13 +0,0 @@
-export function getDeprecationNotice(deprecationInfo, name, label) {
-    let deprecationNotice = '@deprecated';
-    if (deprecationInfo.isDeprecated) {
-        const { note, since } = deprecationInfo.asDeprecated;
-        const sinceText = since.isSome ? ` Since ${since.unwrap().toString()}.` : '';
-        deprecationNotice += ` ${note.toString()}${sinceText}`;
-    }
-    else {
-        const labelText = label ? `${label} ` : '';
-        deprecationNotice += ` ${labelText}${name} has been deprecated`;
-    }
-    return deprecationNotice;
-}