@pezkuwi/typegen 16.5.5

package/src/generate/runtime.ts

@@ -0,0 +1,284 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { RuntimeApiMethodMetadataV16, SiLookupTypeId } from '@pezkuwi/types/interfaces';
+import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
+import type { DefinitionCall, DefinitionCallNamed, Definitions, DefinitionsCall, Registry } from '@pezkuwi/types/types';
+import type { Vec } from '@pezkuwi/types-codec';
+import type { HexString } from '@pezkuwi/util/types';
+
+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, setImports, writeFile } from '../util/index.js';
+import { type ExtraTypes, getDeprecationNotice } from './types.js';
+
+type Apis = [HexString, number][];
+
+const generateCallsTypesTemplate = Handlebars.compile(readTemplate('calls'));
+
+// This works similar to the PATHS_ALIAS set from the PortableRegistry
+const aliases: Record<string, string> = {
+  AssetHubKusamaRuntimeRuntimeCall: 'RuntimeCall',
+  AssetHubPolkadotRuntimeRuntimeCall: 'RuntimeCall',
+  KitchensinkRuntimeRuntimeCall: 'RuntimeCall',
+  OpaqueValue: 'Bytes',
+  PolkadotParachainPrimitivesPrimitivesId: 'ParaId',
+  PolkadotParachainPrimitivesPrimitivesValidationCodeHash: 'ValidationCodeHash',
+  PolkadotPrimitivesV7SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
+  PolkadotPrimitivesV8SlashingOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
+  PolkadotRuntimeRuntimeCall: 'RuntimeCall',
+  PrimitiveTypesH160: 'H160',
+  PrimitiveTypesH256: 'H256',
+  PrimitiveTypesU256: 'U256',
+  SpConsensusBabeOpaqueKeyOwnershipProof: 'OpaqueKeyOwnershipProof',
+  SpConsensusSlotsSlot: 'Slot',
+  SpConsensusSlotsSlotDuration: 'SlotDuration',
+  SpCoreCryptoAccountId32: 'AccountId32',
+  SpCoreOpaqueMetadata: 'OpaqueMetadata',
+  SpRuntimeOpaqueValue: 'Bytes',
+  SpRuntimeUncheckedExtrinsic: 'Extrinsic',
+  StagingKusamaRuntimeRuntimeCall: 'RuntimeCall'
+};
+
+const getTypesViaAlias = (registry: Registry, id: SiLookupTypeId) => {
+  const typeName = registry.lookup.getName(id) || registry.lookup.getTypeDef(id).type;
+
+  if (aliases[typeName]) {
+    return aliases[typeName];
+  }
+
+  return typeName;
+};
+
+/** @internal */
+function getMethods (registry: Registry, methods: Vec<RuntimeApiMethodMetadataV16>) {
+  const result: Record<string, DefinitionCall> = {};
+
+  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: Registry) {
+  const result: DefinitionsCall = {};
+  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: Apis | null, defs: Record<string, Definitions>, registry: Registry): Record<string, Record<string, DefinitionCallNamed>> {
+  const named: Record<string, Record<string, DefinitionCallNamed>> = {};
+  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: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
+  writeFile(dest, (): string => {
+    const allTypes: ExtraTypes = {
+      '@pezkuwi/types-augment': {
+        lookup: {
+          ...lookupDefinitions,
+          ...customLookupDefinitions
+        }
+      },
+      '@pezkuwi/types/interfaces': defaultDefs,
+      ...extraTypes
+    };
+    const imports = createImports(allTypes);
+
+    // find the system.Version in metadata
+    let apis: Apis | null = 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]): [HexString, number] => [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 as Record<string, 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: string; types: string[] } => ({
+          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: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
+  const { metadata, registry } = initMeta(data, extraTypes);
+
+  generateCallTypes(
+    registry,
+    metadata,
+    dest,
+    extraTypes,
+    isStrict,
+    customLookupDefinitions
+  );
+}

package/src/generate/tsDef.ts

@@ -0,0 +1,321 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Registry } from '@pezkuwi/types/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { ModuleTypes } from '../util/imports.js';
+import type { TypeImports } from '../util/index.js';
+
+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';
+
+interface Imports extends TypeImports {
+  interfaces: [string, string][];
+}
+
+const generateTsDefIndexTemplate = Handlebars.compile(readTemplate('tsDef/index'));
+const generateTsDefModuleTypesTemplate = Handlebars.compile(readTemplate('tsDef/moduleTypes'));
+const generateTsDefTypesTemplate = Handlebars.compile(readTemplate('tsDef/types'));
+
+// helper to generate a `readonly <Name>: <Type>;` getter
+/** @internal */
+export function createGetter (definitions: Record<string, ModuleTypes>, name = '', type: string, imports: TypeImports): string {
+  setImports(definitions, imports, [type]);
+
+  return `  readonly ${name}: ${type};\n`;
+}
+
+/** @internal */
+function errorUnhandled (_: Registry, _definitions: Record<string, ModuleTypes>, def: TypeDef, _imports: TypeImports): string {
+  throw new Error(`Generate: ${def.name || ''}: Unhandled type ${TypeDefInfo[def.info]}`);
+}
+
+/** @internal */
+function tsExport (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports): string {
+  return exportInterface(def.lookupIndex, def.name, formatType(registry, definitions, def, imports, false));
+}
+
+/** @internal */
+function tsEnum (registry: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex, name: enumName, sub }: TypeDef, imports: TypeImports, withShortcut = false): string {
+  setImports(definitions, imports, ['Enum']);
+
+  const indent = withShortcut ? '  ' : '';
+  const named = (sub as TypeDef[]).filter(({ name }) => !!name && !name.startsWith('__Unused'));
+  const keys = named.map((def): string => {
+    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/polkadot-js/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 (_: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports, type: 'Int' | 'UInt' = 'Int'): string {
+  setImports(definitions, imports, [type]);
+
+  return exportInterface(def.lookupIndex, def.name, type);
+}
+
+/** @internal */
+function tsNull (_registry: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex = -1, name }: TypeDef, imports: TypeImports): string {
+  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: Registry, definitions: Record<string, ModuleTypes>, resultName = '', getter: 'Ok' | 'Err', def: TypeDef, imports: TypeImports): string {
+  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: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports): string {
+  const [okDef, errorDef] = (def.sub as TypeDef[]);
+  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: Registry, _definitions: Record<string, ModuleTypes>, typeDef: TypeDef, _imports: TypeImports): string {
+  // FIXME
+  return `// SI: ${stringify(typeDef)}`;
+}
+
+/** @internal */
+function tsSet (_: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex, name: setName, sub }: TypeDef, imports: TypeImports): string {
+  setImports(definitions, imports, ['Set']);
+
+  const types = (sub as TypeDef[]).map(({ name }): string => {
+    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: Registry, definitions: Record<string, ModuleTypes>, { lookupIndex, name: structName, sub }: TypeDef, imports: TypeImports): string {
+  setImports(definitions, imports, ['Struct']);
+
+  const keys = (sub as TypeDef[]).map((def): string => {
+    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: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports): string {
+  return tsInt(registry, definitions, def, imports, 'UInt');
+}
+
+/** @internal */
+function tsVec (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports): string {
+  const type = (def.sub as TypeDef).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);
+}
+
+// handlers are defined externally to use - this means that when we do a
+// `generators[typedef.info](...)` TS will show any unhandled types. Rather
+// we are being explicit in having no handlers where we do not support (yet)
+export const typeEncoders: Record<TypeDefInfo, (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports) => string> = {
+  [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: Registry, definitions: Record<string, ModuleTypes>, { types }: { types: Record<string, any> }, imports: Imports): [string, string][] {
+  return Object.entries(types).map(([name, type]): [string, string] => {
+    const def = getTypeDef(isString(type) ? type : stringify(type), { name });
+
+    return [name, typeEncoders[def.info](registry, definitions, def, imports)];
+  });
+}
+
+/** @internal */
+export function generateTsDefFor (registry: Registry, importDefinitions: Record<string, Record<string, ModuleTypes>>, defName: string, { types }: { types: Record<string, any> }, outputDir: string): void {
+  const imports = { ...createImports(importDefinitions, { types }), interfaces: [] } as Imports;
+  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: string; types: string[] } => ({
+        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: Record<string, Record<string, ModuleTypes>>, outputDir: string, generatingPackage: string): void {
+  const registry = new TypeRegistry();
+
+  writeFile(path.join(outputDir, 'types.ts'), (): string => {
+    const definitions = importDefinitions[generatingPackage];
+
+    Object.entries(definitions).forEach(([defName, obj]): void => {
+      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 (): void {
+  generateTsDef(
+    { '@pezkuwi/types/interfaces': defaultDefinitions },
+    'packages/types/src/interfaces',
+    '@pezkuwi/types/interfaces'
+  );
+}