@pezkuwi/typegen 16.5.16 → 16.5.18

package/src/generate/errors.ts

@@ -0,0 +1,75 @@
+// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { VariantDeprecationInfoV16 } from '@pezkuwi/types/interfaces';
+import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
+import type { HexString } from '@pezkuwi/util/types';
+
+import Handlebars from 'handlebars';
+
+import { stringCamelCase } from '@pezkuwi/util';
+
+import { compareName, createImports, initMeta, readTemplate, writeFile } from '../util/index.js';
+import { type ExtraTypes, getDeprecationNotice } from './types.js';
+
+const generateForMetaTemplate = Handlebars.compile(readTemplate('errors'));
+
+/** @internal */
+function generateForMeta (meta: Metadata, dest: string, isStrict: boolean): void {
+  writeFile(dest, (): string => {
+    const imports = createImports({});
+    const { lookup, pallets } = meta.asLatest;
+    const modules = pallets
+      .filter(({ errors }) => errors.isSome)
+      .map((data) => {
+        const name = data.name;
+        const errors = data.errors.unwrap();
+        const deprecationInfo = errors.deprecationInfo.toJSON();
+
+        return {
+          items: lookup.getSiType(errors.type).def.asVariant.variants
+            .map(({ docs, index, name }) => {
+              const rawStatus = deprecationInfo?.[index.toNumber()];
+
+              if (rawStatus) {
+                const deprecationVariantInfo: VariantDeprecationInfoV16 = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
+
+                const deprecationNotice = getDeprecationNotice(deprecationVariantInfo, name.toString());
+                const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
+
+                docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
+              }
+
+              return {
+                docs,
+                name: name.toString()
+              };
+            })
+            .sort(compareName),
+          name: stringCamelCase(name)
+        };
+      })
+      .sort(compareName);
+
+    return generateForMetaTemplate({
+      headerType: 'chain',
+      imports,
+      isStrict,
+      modules,
+      types: [
+        {
+          file: '@pezkuwi/api-base/types',
+          types: ['ApiTypes', 'AugmentedError']
+        }
+      ]
+    });
+  });
+}
+
+// Call `generateForMeta()` with current static metadata
+/** @internal */
+export function generateDefaultErrors (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false): void {
+  const { metadata } = initMeta(data, extraTypes);
+
+  return generateForMeta(metadata, dest, isStrict);
+}

package/src/generate/events.ts

@@ -0,0 +1,165 @@
+// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { VariantDeprecationInfoV16 } from '@pezkuwi/types/interfaces';
+import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
+import type { Definitions } from '@pezkuwi/types/types';
+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 { stringCamelCase } from '@pezkuwi/util';
+
+import { compareName, createImports, formatType, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
+import { ignoreUnusedLookups } from './lookup.js';
+import { type ExtraTypes, getDeprecationNotice } from './types.js';
+
+const generateForMetaTemplate = Handlebars.compile(readTemplate('events'));
+
+// For babel itself we need some extra aliasing
+// Also avoid reserved words to prevent generating invalid TS
+// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#reserved_words
+const ALIAS = [
+  'symbol',
+  'break',
+  'case',
+  'catch',
+  'class',
+  'const',
+  'continue',
+  'debugger',
+  'default',
+  'delete',
+  'do',
+  'else',
+  'export',
+  'extends',
+  'false',
+  'finally',
+  'for',
+  'function',
+  'if',
+  'import',
+  'in',
+  'instanceof',
+  'new',
+  'null',
+  'return',
+  'static',
+  'super',
+  'switch',
+  'this',
+  'throw',
+  'true',
+  'try',
+  'typeof',
+  'var',
+  'void',
+  'while',
+  'with',
+  'yield'
+];
+
+/** @internal */
+function generateForMeta (meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void {
+  writeFile(dest, (): string => {
+    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, registry } = meta.asLatest;
+    const usedTypes = new Set<string>([]);
+    const modules = pallets
+      .filter(({ events }) => events.isSome)
+      .map((data) => {
+        const name = data.name;
+        const events = data.events.unwrap();
+        const deprecationInfo = events.deprecationInfo.toJSON();
+
+        return {
+          items: lookup.getSiType(events.type).def.asVariant.variants
+            .map(({ docs, fields, index, name }) => {
+              const rawStatus = deprecationInfo?.[index.toNumber()];
+
+              if (rawStatus) {
+                const deprecationVariantInfo: VariantDeprecationInfoV16 = meta.registry.createTypeUnsafe('VariantDeprecationInfoV16', [rawStatus]);
+                const deprecationNotice = getDeprecationNotice(deprecationVariantInfo, name.toString());
+                const notice = docs.length ? ['', deprecationNotice] : [deprecationNotice];
+
+                docs.push(...notice.map((text) => meta.registry.createType('Text', text)));
+              }
+
+              const args = fields
+                .map(({ type }) => lookup.getTypeDef(type))
+                .map((typeDef) => {
+                  const arg = rebrandTypeName(typeDef.lookupName || '') || formatType(registry, allDefs, typeDef, imports);
+
+                  // Add the type to the list of used types
+                  if (!(imports.primitiveTypes[arg])) {
+                    usedTypes.add(arg);
+                  }
+
+                  return arg;
+                });
+
+              const names = fields
+                .map(({ name }) => registry.lookup.sanitizeField(name)[0])
+                .filter((n): n is string => !!n);
+
+              setImports(allDefs, imports, args);
+
+              return {
+                docs,
+                name: name.toString(),
+                type: names.length !== 0 && names.length === args.length
+                  ? `[${names.map((n, i) => `${ALIAS.includes(n) ? `${n}_` : n}: ${args[i]}`).join(', ')}], { ${names.map((n, i) => `${n}: ${args[i]}`).join(', ')} }`
+                  : `[${args.join(', ')}]`
+              };
+            })
+            .sort(compareName),
+          name: stringCamelCase(name)
+        };
+      })
+      .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: string; types: string[] } => ({
+          file: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
+          types: Object.keys(imports.localTypes[packagePath])
+        })),
+        {
+          file: '@pezkuwi/api-base/types',
+          types: ['ApiTypes', 'AugmentedEvent']
+        }
+      ]
+    });
+  });
+}
+
+// Call `generateForMeta()` with current static metadata
+/** @internal */
+export function generateDefaultEvents (dest: string, data: HexString, extraTypes: ExtraTypes = {}, isStrict = false, customLookupDefinitions?: Definitions): void {
+  const { metadata } = initMeta(data, extraTypes);
+
+  return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}

package/src/generate/index.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { generateDefaultConsts } from './consts.js';
+export { generateDefaultErrors } from './errors.js';
+export { generateDefaultEvents } from './events.js';
+export { generateDefaultInterface } from './interfaceRegistry.js';
+export { generateDefaultLookup } from './lookup.js';
+export { generateDefaultQuery } from './query.js';
+export { generateDefaultRpc } from './rpc.js';
+export { generateDefaultRuntime } from './runtime.js';
+export { generateDefaultTsDef } from './tsDef.js';
+export { generateDefaultTx } from './tx.js';

package/src/generate/interfaceRegistry.ts

@@ -0,0 +1,85 @@
+// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { ModuleTypes } from '../util/imports.js';
+
+import Handlebars from 'handlebars';
+
+import { Json, Raw } from '@pezkuwi/types/codec';
+import { TypeRegistry } from '@pezkuwi/types/create';
+import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
+import * as defaultPrimitives from '@pezkuwi/types/primitive';
+
+import { createImports, readTemplate, setImports, writeFile } from '../util/index.js';
+
+const primitiveClasses = {
+  ...defaultPrimitives,
+  Json,
+  Raw
+};
+
+const generateInterfaceTypesTemplate = Handlebars.compile(readTemplate('interfaceRegistry'));
+
+/** @internal */
+export function generateInterfaceTypes (importDefinitions: Record<string, Record<string, ModuleTypes>>, dest: string): void {
+  const registry = new TypeRegistry();
+
+  writeFile(dest, (): string => {
+    Object.entries(importDefinitions).reduce((acc, def) => Object.assign(acc, def), {});
+
+    const imports = createImports(importDefinitions);
+    const definitions = imports.definitions;
+    const items: string[] = [];
+
+    // first we create imports for our known classes from the API
+    Object
+      .keys(primitiveClasses)
+      .filter((name) => !name.includes('Generic'))
+      .forEach((primitiveName): void => {
+        setImports(definitions, imports, [primitiveName]);
+
+        items.push(primitiveName);
+      });
+
+    const existingTypes: Record<string, boolean> = {};
+
+    // ensure we have everything registered since we will get the definition
+    // form the available types (so any unknown should show after this)
+    Object.values(definitions).forEach(({ types }) => {
+      registry.register(types as Record<string, string>);
+    });
+
+    // create imports for everything that we have available
+    Object.values(definitions).forEach(({ types }) => {
+      setImports(definitions, imports, Object.keys(types));
+
+      const uniqueTypes = Object.keys(types).filter((type) => !existingTypes[type]);
+
+      uniqueTypes.forEach((type): void => {
+        existingTypes[type] = true;
+
+        items.push(type);
+      });
+    });
+
+    return generateInterfaceTypesTemplate({
+      headerType: 'defs',
+      imports,
+      items: items.sort((a, b) => a.localeCompare(b)),
+      types: [
+        ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
+          file: packagePath,
+          types: Object.keys(imports.localTypes[packagePath])
+        }))
+      ]
+    });
+  });
+}
+
+// Generate `packages/types/src/interfaceRegistry.ts`, the registry of all interfaces
+export function generateDefaultInterface (): void {
+  generateInterfaceTypes(
+    { '@pezkuwi/types/interfaces': defaultDefinitions },
+    'packages/types-augment/src/registry/interfaces.ts'
+  );
+}

package/src/generate/lookup.ts

@@ -0,0 +1,322 @@
+// Copyright 2017-2025 @pezkuwi/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { PortableType, SiLookupTypeId, SiPath, SiTypeParameter } from '@pezkuwi/types/interfaces';
+import type { PortableRegistry } from '@pezkuwi/types/metadata';
+import type { Registry } from '@pezkuwi/types/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { HexString } from '@pezkuwi/util/types';
+
+import Handlebars from 'handlebars';
+import path from 'node:path';
+
+import * as defaultDefinitions from '@pezkuwi/types/interfaces/definitions';
+import staticAhDicle from '@pezkuwi/types-support/metadata/v15/asset-hub-dicle-hex';
+import staticAhPezkuwi from '@pezkuwi/types-support/metadata/v15/asset-hub-pezkuwi-hex';
+import staticBizinikiwi from '@pezkuwi/types-support/metadata/v15/bizinikiwi-hex';
+import staticDicle from '@pezkuwi/types-support/metadata/v15/dicle-hex';
+import staticPezkuwi from '@pezkuwi/types-support/metadata/v15/pezkuwi-hex';
+import { isString, stringify } from '@pezkuwi/util';
+
+import { createImports, exportInterface, initMeta, readTemplate, rebrandTypeName, type TypeImports, writeFile } from '../util/index.js';
+import { typeEncoders } from './tsDef.js';
+
+// Deep rebrand TypeDef including all nested sub types
+// isTopLevel indicates whether this is a top-level type (should set name from lookupName) or a sub type (preserve name)
+function deepRebrandTypeDef (typeDef: TypeDef, isTopLevel = true): TypeDef {
+  const rebrandedLookupName = typeDef.lookupName ? rebrandTypeName(typeDef.lookupName) : typeDef.lookupName;
+
+  const rebranded: TypeDef = {
+    ...typeDef,
+    type: rebrandTypeName(typeDef.type),
+    // For top-level types: set name from lookupName (mimics original: typeDef.name = typeDef.lookupName)
+    // For sub types (enum variants, struct fields): preserve the original name (field/variant name)
+    name: isTopLevel ? (rebrandedLookupName || typeDef.name) : typeDef.name,
+    lookupName: rebrandedLookupName,
+    lookupNameRoot: typeDef.lookupNameRoot ? rebrandTypeName(typeDef.lookupNameRoot) : typeDef.lookupNameRoot
+  };
+
+  // Recursively rebrand sub types (mark as not top-level)
+  if (typeDef.sub) {
+    if (Array.isArray(typeDef.sub)) {
+      rebranded.sub = typeDef.sub.map((s) => deepRebrandTypeDef(s, false));
+    } else {
+      rebranded.sub = deepRebrandTypeDef(typeDef.sub, false);
+    }
+  }
+
+  return rebranded;
+}
+
+// Record<string, >
+interface ParsedDef {
+  _set: Record<string, number>;
+
+  [key: string]: string | Record<string, string> | Record<string, number>;
+}
+
+const WITH_TYPEDEF = false;
+
+const generateLookupDefsTmpl = Handlebars.compile(readTemplate('lookup/defs'));
+const generateLookupDefsNamedTmpl = Handlebars.compile(readTemplate('lookup/defs-named'));
+const generateLookupIndexTmpl = Handlebars.compile(readTemplate('lookup/index'));
+const generateLookupTypesTmpl = Handlebars.compile(readTemplate('lookup/types'));
+const generateRegistryTmpl = Handlebars.compile(readTemplate('interfaceRegistry'));
+
+function generateParamType (registry: Registry, { name, type }: SiTypeParameter): string {
+  if (type.isSome) {
+    const link = registry.lookup.types[type.unwrap().toNumber()];
+
+    if (link.type.path.length) {
+      return generateTypeDocs(registry, null, link.type.path, link.type.params);
+    }
+  }
+
+  return name.toString();
+}
+
+function generateTypeDocs (registry: Registry, id: SiLookupTypeId | null, path: SiPath, params: SiTypeParameter[]): string {
+  return `${id ? `${registry.createLookupType(id)}${path.length ? ': ' : ''}` : ''}${path.map((p) => p.toString()).join('::')}${params.length ? `<${params.map((p) => generateParamType(registry, p)).join(', ')}>` : ''}`;
+}
+
+function formatObject (lines: string[]): string[] {
+  const max = lines.length - 1;
+
+  return [
+    '{',
+    ...lines.map((l, index) =>
+      (l.endsWith(',') || l.endsWith('{') || index === max || lines[index + 1].endsWith('}') || lines[index + 1].endsWith('}'))
+        ? l
+        : `${l},`
+    ),
+    '}'
+  ];
+}
+
+function expandSet (parsed: Record<string, number>): string[] {
+  return formatObject(
+    Object.entries(parsed).reduce<string[]>((all, [k, v]) => {
+      all.push(`${k}: ${v}`);
+
+      return all;
+    }, [])
+  );
+}
+
+function expandObject (parsed: ParsedDef): string[] {
+  if (parsed._set) {
+    return expandSet(parsed._set);
+  }
+
+  return formatObject(
+    Object.entries(parsed).reduce<string[]>((all, [k, v]) => {
+      const inner = isString(v)
+        ? expandType(v)
+        : Array.isArray(v)
+          ? [`[${(v as string[]).map((e) => `'${e}'`).join(', ')}]`]
+          : expandObject(v as ParsedDef);
+
+      inner.forEach((l, index): void => {
+        all.push(`${
+          index === 0
+            ? `${k}: ${l}`
+            : `${l}`
+        }`);
+      });
+
+      return all;
+    }, [])
+  );
+}
+
+function expandType (encoded: string): string[] {
+  if (!encoded.startsWith('{')) {
+    return [`'${rebrandTypeName(encoded)}'`];
+  }
+
+  return expandObject(JSON.parse(encoded) as ParsedDef);
+}
+
+function expandDefToString ({ lookupNameRoot, type }: TypeDef, indent: number): string {
+  if (lookupNameRoot) {
+    return `'${rebrandTypeName(lookupNameRoot)}'`;
+  }
+
+  const lines = expandType(type);
+  let inc = 0;
+
+  return lines.map((l, index) => {
+    let r: string;
+
+    if (l.endsWith('{')) {
+      r = index === 0
+        ? l
+        : `${' '.padStart(indent + inc)}${l}`;
+      inc += 2;
+    } else {
+      if (l.endsWith('},') || l.endsWith('}')) {
+        inc -= 2;
+      }
+
+      r = index === 0
+        ? l
+        : `${' '.padStart(indent + inc)}${l}`;
+    }
+
+    return r;
+  }).join('\n');
+}
+
+function getFilteredTypes (lookup: PortableRegistry, exclude: string[] = []): [PortableType, TypeDef][] {
+  const named = lookup.types.filter(({ id }) => !!lookup.getTypeDef(id).lookupName);
+  const names = named.map(({ id }) => lookup.getName(id));
+
+  return named
+    .filter((_, index) =>
+      !names.some((n, iindex) =>
+        index > iindex &&
+        n === names[index]
+      )
+    )
+    .map((p): [PortableType, TypeDef] => [p, lookup.getTypeDef(p.id)])
+    .filter(([, typeDef]) => !exclude.includes(typeDef.lookupName || '<invalid>'));
+}
+
+function generateLookupDefs (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
+  writeFile(path.join(destDir, `${subPath || 'definitions'}.ts`), (): string => {
+    const all = filtered.map(([{ id, type: { params, path } }, typeDef]) => {
+      const typeLookup = registry.createLookupType(id);
+      const def = expandDefToString(typeDef, subPath ? 2 : 4);
+
+      return {
+        docs: [
+          generateTypeDocs(registry, id, path, params),
+          WITH_TYPEDEF
+            ? `@typeDef ${stringify(typeDef)}`
+            : null
+        ].filter((d): d is string => !!d),
+        type: { def, typeLookup, typeName: typeDef.lookupName ? rebrandTypeName(typeDef.lookupName) : undefined }
+      };
+    });
+    const max = all.length - 1;
+
+    return (subPath ? generateLookupDefsNamedTmpl : generateLookupDefsTmpl)({
+      defs: all.map(({ docs, type }, i) => {
+        const { def, typeLookup, typeName } = type;
+
+        return {
+          defs: [
+            [typeName || typeLookup, `${def}${i !== max ? ',' : ''}`]
+          ].map(([n, t]) => `${n}: ${t}`),
+          docs
+        };
+      }),
+      headerType: 'defs'
+    });
+  });
+}
+
+function generateLookupTypes (registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath?: string): void {
+  const imports = {
+    ...createImports(
+      { '@pezkuwi/types/interfaces': defaultDefinitions },
+      { types: {} }
+    ),
+    interfaces: []
+  };
+  const items = filtered
+    .map(([, typeDef]) => {
+      // Deep rebrand the type names (including nested sub types) before generating interfaces
+      const rebranded = deepRebrandTypeDef(typeDef);
+
+      return rebranded.lookupNameRoot && rebranded.lookupName
+        ? exportInterface(rebranded.lookupIndex, rebranded.lookupName, rebranded.lookupNameRoot)
+        : typeEncoders[rebranded.info](registry, imports.definitions, rebranded, imports);
+    })
+    .filter((t): t is string => !!t)
+    .map((t) => t.replace(/\nexport /, '\n'));
+
+  writeFile(path.join(destDir, `types${subPath ? `-${subPath}` : ''}.ts`), () => generateLookupTypesTmpl({
+    headerType: 'defs',
+    imports,
+    items: items.map((l) =>
+      l
+        .split('\n')
+        .map((l) => l.length ? `  ${l}` : '')
+        .join('\n')
+    ),
+    types: [
+      ...Object.keys(imports.localTypes).sort().map((packagePath): { file: string; types: string[] } => ({
+        file: packagePath,
+        types: Object.keys(imports.localTypes[packagePath])
+      }))
+    ]
+  }), true);
+  writeFile(path.join(destDir, 'index.ts'), () => generateLookupIndexTmpl({ headerType: 'defs' }), true);
+}
+
+function generateRegistry (_registry: Registry, filtered: [PortableType, TypeDef][], destDir: string, subPath: string): void {
+  writeFile(path.join(destDir, `${subPath}.ts`), (): string => {
+    const items = filtered
+      .map(([, { lookupName }]) => lookupName ? rebrandTypeName(lookupName) : lookupName)
+      .filter((n): n is string => !!n)
+      .sort()
+      .reduce((all: string[], n) => all.includes(n) ? all : all.concat(n), []);
+    const imports = createImports({}, { types: {} });
+
+    imports.lookupTypes = items.reduce((all, n) => ({ ...all, [n]: true }), {});
+
+    return generateRegistryTmpl({
+      headerType: 'defs',
+      imports,
+      items,
+      types: []
+    });
+  }, true);
+}
+
+function generateLookup (destDir: string, entries: [string, HexString][]): void {
+  entries.reduce<string[]>((exclude, [subPath, staticMeta]): string[] => {
+    const { lookup, registry } = initMeta(staticMeta).metadata.asLatest;
+    const filtered = getFilteredTypes(lookup, exclude);
+
+    generateLookupDefs(registry, filtered, destDir, subPath);
+    generateLookupTypes(registry, filtered, destDir, subPath);
+    generateRegistry(registry, filtered, destDir, subPath === 'lookup' ? 'registry' : `../registry/${subPath}`);
+
+    return exclude.concat(
+      ...filtered
+        .map(([, typeDef]) => typeDef.lookupName)
+        .filter((n): n is string => !!n)
+    );
+  }, []);
+}
+
+// Generate `packages/types/src/lookup/*s`, the registry of all lookup types
+export function generateDefaultLookup (destDir = 'packages/types-augment/src/lookup', staticData?: HexString): void {
+  generateLookup(
+    destDir,
+    staticData
+      ? [['lookup', staticData]]
+      : [
+        ['bizinikiwi', staticBizinikiwi],
+        ['pezkuwi', staticPezkuwi],
+        ['dicle', staticDicle],
+        ['assetHubPezkuwi', staticAhPezkuwi],
+        ['assetHubDicle', staticAhDicle]
+      ]
+  );
+}
+
+// Based on a list of types, it filters out the lookup types that are not needed.
+export function ignoreUnusedLookups (usedTypes: string[], imports: TypeImports) {
+  const usedStringified = usedTypes.toString();
+
+  const [lookupKey, typeDefinitions] = Object.entries(imports.localTypes).find(([typeModule, _]) => typeModule.includes('/lookup')) || ['', {}];
+
+  Object.keys(typeDefinitions).forEach((typeDef) => {
+    if (!(usedStringified.includes(typeDef))) {
+      delete (imports.localTypes[lookupKey])[typeDef];
+    }
+  });
+}