@pezkuwi/typegen 16.5.16 → 16.5.18

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

@@ -0,0 +1,110 @@
+import Handlebars from 'handlebars';
+import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
+import staticBizinikiwi from '@pezkuwi/types-support/metadata/static-bizinikiwi';
+import { createImports, formatType, getSimilarTypes, initMeta, readTemplate, setImports, writeFile } from '../util/index.js';
+const StorageKeyType = 'StorageKey | string | Uint8Array | any';
+const generateRpcTypesTemplate = Handlebars.compile(readTemplate('rpc'));
+/** @internal */
+export function generateRpcTypes(registry, importDefinitions, dest, extraTypes) {
+    writeFile(dest, () => {
+        const allTypes = { '@pezkuwi/types/interfaces': importDefinitions, ...extraTypes };
+        const imports = createImports(allTypes);
+        const definitions = imports.definitions;
+        const allDefs = Object.entries(allTypes).reduce((defs, [path, obj]) => {
+            return Object.entries(obj).reduce((defs, [key, value]) => ({ ...defs, [`${path}/${key}`]: value }), defs);
+        }, {});
+        const rpcKeys = Object
+            .keys(definitions)
+            .filter((key) => Object.keys(definitions[key].rpc || {}).length !== 0)
+            .sort();
+        const additional = {};
+        const modules = rpcKeys.map((sectionFullName) => {
+            const rpc = definitions[sectionFullName].rpc || {};
+            const section = sectionFullName.split('/').pop();
+            const allMethods = Object.keys(rpc).sort().map((methodName) => {
+                const def = rpc[methodName];
+                let args;
+                let type;
+                let generic;
+                // These are too hard to type with generics, do manual overrides
+                if (section === 'state') {
+                    setImports(allDefs, imports, ['Codec', 'Hash', 'StorageKey', 'Vec']);
+                    if (methodName === 'getStorage') {
+                        generic = 'T = Codec';
+                        args = [`key: ${StorageKeyType}, block?: Hash | Uint8Array | string`];
+                        type = 'T';
+                    }
+                    else if (methodName === 'queryStorage') {
+                        generic = 'T = Codec[]';
+                        args = [`keys: Vec<StorageKey> | (${StorageKeyType})[], fromBlock?: Hash | Uint8Array | string, toBlock?: Hash | Uint8Array | string`];
+                        type = '[Hash, T][]';
+                    }
+                    else if (methodName === 'queryStorageAt') {
+                        generic = 'T = Codec[]';
+                        args = [`keys: Vec<StorageKey> | (${StorageKeyType})[], at?: Hash | Uint8Array | string`];
+                        type = 'T';
+                    }
+                    else if (methodName === 'subscribeStorage') {
+                        generic = 'T = Codec[]';
+                        args = [`keys?: Vec<StorageKey> | (${StorageKeyType})[]`];
+                        type = 'T';
+                    }
+                }
+                if (args === undefined) {
+                    setImports(allDefs, imports, [def.type]);
+                    args = def.params.map((param) => {
+                        const similarTypes = getSimilarTypes(registry, definitions, param.type, imports);
+                        setImports(allDefs, imports, [param.type, ...similarTypes]);
+                        return `${param.name}${param.isOptional ? '?' : ''}: ${similarTypes.join(' | ')}`;
+                    });
+                    type = formatType(registry, allDefs, def.type, imports);
+                    generic = '';
+                }
+                const item = {
+                    args: args.join(', '),
+                    docs: def.deprecated
+                        ? [`@deprecated ${def.deprecated}`, def.description]
+                        : [def.description],
+                    generic,
+                    name: methodName,
+                    type
+                };
+                if (def.aliasSection) {
+                    if (!additional[def.aliasSection]) {
+                        additional[def.aliasSection] = {
+                            items: [],
+                            name: def.aliasSection
+                        };
+                    }
+                    additional[def.aliasSection].items.push(item);
+                    return null;
+                }
+                return item;
+            }).filter((item) => !!item);
+            return {
+                items: allMethods,
+                name: section || 'unknown'
+            };
+        }).concat(...Object.values(additional)).sort((a, b) => a.name.localeCompare(b.name));
+        imports.typesTypes['Observable'] = true;
+        return generateRpcTypesTemplate({
+            headerType: 'chain',
+            imports,
+            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/rpc-core/types',
+                    types: ['AugmentedRpc']
+                }
+            ]
+        });
+    });
+}
+export function generateDefaultRpc(dest = 'packages/rpc-augment/src/augment/jsonrpc.ts', extraTypes = {}) {
+    const { registry } = initMeta(staticBizinikiwi, extraTypes);
+    generateRpcTypes(registry, defaultDefinitions, dest, extraTypes);
+}

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

@@ -0,0 +1,228 @@
+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

@@ -0,0 +1,246 @@
+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');
+}