@pezkuwi/typegen 16.5.18 → 16.5.31

package/build/util/imports.js

@@ -1,121 +0,0 @@
-import * as codecClasses from '@pezkuwi/types/codec';
-import * as extrinsicClasses from '@pezkuwi/types/extrinsic';
-import * as genericClasses from '@pezkuwi/types/generic';
-import * as primitiveClasses from '@pezkuwi/types/primitive';
-import { getTypeDef, TypeDefInfo } from '@pezkuwi/types-create';
-function splitAlternatives(type) {
-    const alternatives = [];
-    let beginOfAlternative = 1;
-    let level = 0;
-    // we assume that the string starts with '['
-    for (let i = 1, count = type.length; i < count; i++) {
-        if (level === 0) {
-            switch (type[i]) {
-                case ']':
-                case ',':
-                case '|':
-                    alternatives.push(type.substring(beginOfAlternative, i).trim());
-                    beginOfAlternative = i + 1;
-                    break;
-            }
-        }
-        switch (type[i]) {
-            case '[':
-            case '(':
-            case '<':
-                level++;
-                break;
-            case ']':
-            case ')':
-            case '>':
-                level--;
-                break;
-        }
-    }
-    return alternatives;
-}
-/** @internal */
-export function setImports(allDefs, imports, types) {
-    const { codecTypes, extrinsicTypes, genericTypes, ignoredTypes, localTypes, metadataTypes, primitiveTypes, typesTypes } = imports;
-    types.filter((t) => !!t).forEach((type) => {
-        if (ignoredTypes.includes(type)) {
-            // do nothing
-        }
-        else if (['AnyNumber', 'CallFunction', 'Codec', 'IExtrinsic', 'IMethod', 'ITuple'].includes(type)) {
-            typesTypes[type] = true;
-        }
-        else if (['Metadata', 'PortableRegistry'].includes(type)) {
-            metadataTypes[type] = true;
-        }
-        else if (codecClasses[type]) {
-            codecTypes[type] = true;
-        }
-        else if (extrinsicClasses[type]) {
-            extrinsicTypes[type] = true;
-        }
-        else if (genericClasses[type]) {
-            genericTypes[type] = true;
-        }
-        else if (primitiveClasses[type]) {
-            primitiveTypes[type] = true;
-        }
-        else if (type.startsWith('[') && type.includes('|')) {
-            const splitTypes = splitAlternatives(type);
-            setImports(allDefs, imports, splitTypes);
-        }
-        else if (type.includes('<') || type.includes('(') || type.includes('[')) {
-            // If the type is a bit special (tuple, fixed u8, nested type...), then we
-            // need to parse it with `getTypeDef`.
-            const typeDef = getTypeDef(type);
-            setImports(allDefs, imports, [TypeDefInfo[typeDef.info]]);
-            // TypeDef.sub is a `TypeDef | TypeDef[]`
-            if (Array.isArray(typeDef.sub)) {
-                typeDef.sub.forEach((subType) => setImports(allDefs, imports, [subType.lookupName || subType.type]));
-            }
-            else if (typeDef.sub && (typeDef.info !== TypeDefInfo.VecFixed || typeDef.sub.type !== 'u8')) {
-                // typeDef.sub is a TypeDef in this case
-                setImports(allDefs, imports, [typeDef.sub.lookupName || typeDef.sub.type]);
-            }
-        }
-        else {
-            // find this module inside the exports from the rest
-            const [moduleName] = Object.entries(allDefs).find(([, { types }]) => Object.keys(types).includes(type)) || [null];
-            if (moduleName) {
-                localTypes[moduleName][type] = true;
-            }
-        }
-    });
-}
-/** @internal */
-export function createImports(importDefinitions, { types } = { types: {} }) {
-    const definitions = {};
-    const typeToModule = {};
-    Object.entries(importDefinitions).forEach(([packagePath, packageDef]) => {
-        Object.entries(packageDef).forEach(([name, moduleDef]) => {
-            const fullName = `${packagePath}/${name}`;
-            definitions[fullName] = moduleDef;
-            Object.keys(moduleDef.types).forEach((type) => {
-                if (typeToModule[type]) {
-                    console.warn(`\t\tWARN: Overwriting duplicated type '${type}' ${typeToModule[type]} -> ${fullName}`);
-                }
-                typeToModule[type] = fullName;
-            });
-        });
-    });
-    return {
-        codecTypes: {},
-        definitions,
-        extrinsicTypes: {},
-        genericTypes: {},
-        ignoredTypes: Object.keys(types),
-        localTypes: Object.keys(definitions).reduce((local, mod) => {
-            local[mod] = {};
-            return local;
-        }, {}),
-        lookupTypes: {},
-        metadataTypes: {},
-        primitiveTypes: {},
-        typeToModule,
-        typesTypes: {}
-    };
-}

package/build/util/index.d.ts

@@ -1,16 +0,0 @@
-export * from './assert.js';
-export * from './derived.js';
-export * from './docs.js';
-export * from './file.js';
-export * from './formatting.js';
-export * from './imports.js';
-export * from './initMeta.js';
-export * from './register.js';
-export * from './wsMeta.js';
-interface Cmp {
-    name: {
-        toString(): string;
-    };
-}
-export declare function compareName(a: Cmp, b: Cmp): number;
-export declare function rebrandTypeName(typeName: string): string;

package/build/util/index.js

@@ -1,34 +0,0 @@
-export * from './assert.js';
-export * from './derived.js';
-export * from './docs.js';
-export * from './file.js';
-export * from './formatting.js';
-export * from './imports.js';
-export * from './initMeta.js';
-export * from './register.js';
-export * from './wsMeta.js';
-export function compareName(a, b) {
-    return a.name.toString().localeCompare(b.name.toString());
-}
-export function rebrandTypeName(typeName) {
-    return typeName
-        // Main projects
-        .replace(/Polkadot/g, 'Pezkuwi')
-        .replace(/Substrate/g, 'Bizinikiwi')
-        .replace(/Cumulus/g, 'Pezcumulus')
-        // Networks
-        .replace(/Kusama/g, 'Dicle')
-        .replace(/Westend/g, 'Zagros')
-        .replace(/Rococo/g, 'Pezkuwichain')
-        // Chain types
-        .replace(/Parachain/g, 'Teyrchain')
-        // Module prefixes (in PascalCase type names)
-        .replace(/Frame(?=[A-Z])/g, 'Pezframe')
-        .replace(/Pallet(?=[A-Z])/g, 'Pezpallet')
-        // Primitives prefixes (sp_ becomes Sp in type names)
-        .replace(/^Sp(?=[A-Z])/g, 'Pezsp')
-        .replace(/([^a-zA-Z])Sp(?=[A-Z])/g, '$1Pezsp')
-        // Client prefixes (sc_ becomes Sc in type names)
-        .replace(/^Sc(?=[A-Z])/g, 'Pezsc')
-        .replace(/([^a-zA-Z])Sc(?=[A-Z])/g, '$1Pezsc');
-}

package/build/util/initMeta.d.ts

@@ -1,12 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-import type { ExtraTypes } from '../generate/types.js';
-import { Metadata, TypeRegistry } from '@pezkuwi/types';
-interface Result {
-    metadata: Metadata;
-    registry: TypeRegistry;
-}
-/**
- * This helper method has been transitioned to work with V14, V15 and up.
- */
-export declare function initMeta(staticMeta: HexString, extraTypes?: ExtraTypes): Result;
-export {};

package/build/util/initMeta.js

@@ -1,19 +0,0 @@
-import { Metadata, TypeRegistry } from '@pezkuwi/types';
-import { registerDefinitions } from './register.js';
-/**
- * This helper method has been transitioned to work with V14, V15 and up.
- */
-export function initMeta(staticMeta, extraTypes = {}) {
-    const registry = new TypeRegistry();
-    registerDefinitions(registry, extraTypes);
-    let metadata;
-    try {
-        const opaqueMetadata = registry.createType('Option<OpaqueMetadata>', registry.createType('Raw', staticMeta).toU8a()).unwrap();
-        metadata = new Metadata(registry, opaqueMetadata.toHex());
-    }
-    catch {
-        metadata = new Metadata(registry, staticMeta);
-    }
-    registry.setMetadata(metadata);
-    return { metadata, registry };
-}

package/build/util/register.d.ts

@@ -1,4 +0,0 @@
-import type { TypeRegistry } from '@pezkuwi/types/create';
-export declare function registerDefinitions(registry: TypeRegistry, extras: Record<string, Record<string, {
-    types: Record<string, any>;
-}>>): void;

package/build/util/register.js

@@ -1,7 +0,0 @@
-export function registerDefinitions(registry, extras) {
-    Object.values(extras).forEach((def) => {
-        Object.values(def).forEach(({ types }) => {
-            registry.register(types);
-        });
-    });
-}

package/build/util/wsMeta.d.ts

@@ -1,4 +0,0 @@
-import type { HexString } from '@pezkuwi/util/types';
-export declare function getMetadataViaWs(endpoint: string, metadataVer?: number): Promise<HexString>;
-export declare function getRpcMethodsViaWs(endpoint: string): Promise<string[]>;
-export declare function getRuntimeVersionViaWs(endpoint: string): Promise<[apiHash: string, apiVersion: number][]>;

package/build/util/wsMeta.js

@@ -1,55 +0,0 @@
-import { promiseTracker } from '@pezkuwi/api/promise/decorateMethod';
-import { TypeRegistry } from '@pezkuwi/types';
-import { stringify, u8aToHex } from '@pezkuwi/util';
-import { WebSocket } from '@pezkuwi/x-ws';
-async function getWsData(endpoint, method, params) {
-    return new Promise((resolve, reject) => {
-        const tracker = promiseTracker(resolve, reject);
-        try {
-            const websocket = new WebSocket(endpoint);
-            websocket.onclose = (event) => {
-                if (event.code !== 1000) {
-                    tracker.reject(new Error(`disconnected, code: '${event.code}' reason: '${event.reason}'`));
-                }
-            };
-            websocket.onerror = (event) => {
-                tracker.reject(new Error(`WebSocket error:: ${stringify(event)}`));
-            };
-            websocket.onopen = () => {
-                console.log('connected');
-                params
-                    ? websocket.send(`{"id":"1","jsonrpc":"2.0","method":"${method}","params":[${params.map((param) => `"${param}"`).join(',')}]}`)
-                    : websocket.send(`{"id":"1","jsonrpc":"2.0","method":"${method}","params":[]}`);
-            };
-            websocket.onmessage = (message) => {
-                try {
-                    tracker.resolve(JSON.parse(message.data).result);
-                }
-                catch (error) {
-                    tracker.reject(error);
-                }
-                websocket.close();
-            };
-        }
-        catch (error) {
-            tracker.reject(error);
-        }
-    });
-}
-export async function getMetadataViaWs(endpoint, metadataVer) {
-    const registry = new TypeRegistry();
-    if (metadataVer) {
-        return await getWsData(endpoint, 'state_call', ['Metadata_metadata_at_version', u8aToHex(registry.createType('u32', metadataVer).toU8a())]);
-    }
-    else {
-        return await getWsData(endpoint, 'state_getMetadata');
-    }
-}
-export async function getRpcMethodsViaWs(endpoint) {
-    const result = await getWsData(endpoint, 'rpc_methods');
-    return result.methods;
-}
-export async function getRuntimeVersionViaWs(endpoint) {
-    const result = await getWsData(endpoint, 'state_getRuntimeVersion');
-    return result.apis;
-}

package/build-tsc-cjs/packageDetect.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const packageInfo_1 = require("@pezkuwi/api/packageInfo");
-const packageInfo_2 = require("@pezkuwi/rpc-provider/packageInfo");
-const packageInfo_3 = require("@pezkuwi/types/packageInfo");
-const util_1 = require("@pezkuwi/util");
-const packageInfo_js_1 = require("./packageInfo.js");
-(0, util_1.detectPackage)(packageInfo_js_1.packageInfo, null, [packageInfo_1.packageInfo, packageInfo_2.packageInfo, packageInfo_3.packageInfo]);

package/build-tsc-cjs/packageInfo.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageInfo = void 0;
-exports.packageInfo = { name: '@pezkuwi/typegen', path: typeof __dirname === 'string' ? __dirname : 'auto', type: 'cjs', version: '16.5.18' };

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

@@ -1,87 +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, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
-import { ignoreUnusedLookups } from './lookup.js';
-import { getDeprecationNotice } from './types.js';
-const generateForMetaTemplate = Handlebars.compile(readTemplate('consts'));
-/** @internal */
-function generateForMeta(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, registry } = meta.asLatest;
-        const usedTypes = new Set([]);
-        const modules = pallets
-            .filter(({ constants }) => constants.length > 0)
-            .map(({ constants, name }) => {
-            if (!isStrict) {
-                setImports(allDefs, imports, ['Codec']);
-            }
-            const items = constants
-                .map(({ deprecationInfo, docs, name, type }) => {
-                const typeDef = lookup.getTypeDef(type);
-                const returnType = rebrandTypeName(typeDef.lookupName || '') || formatType(registry, allDefs, typeDef, imports);
-                if (!deprecationInfo.isNotDeprecated) {
-                    const deprecationNotice = getDeprecationNotice(deprecationInfo, stringCamelCase(name), 'Constant');
-                    const items = docs.length
-                        ? ['', deprecationNotice]
-                        : [deprecationNotice];
-                    docs.push(...items.map((text) => registry.createType('Text', text)));
-                }
-                // Add the type to the list of used types
-                if (!(imports.primitiveTypes[returnType])) {
-                    usedTypes.add(returnType);
-                }
-                setImports(allDefs, imports, [returnType]);
-                return {
-                    docs,
-                    name: stringCamelCase(name),
-                    type: returnType
-                };
-            })
-                .sort(compareName);
-            return {
-                items,
-                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: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-                    types: Object.keys(imports.localTypes[packagePath])
-                })),
-                {
-                    file: '@pezkuwi/api-base/types',
-                    types: ['ApiTypes', 'AugmentedConst']
-                }
-            ]
-        });
-    });
-}
-/** @internal */
-export function generateDefaultConsts(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
-    const { metadata } = initMeta(data, extraTypes);
-    return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

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

@@ -1,55 +0,0 @@
-import Handlebars from 'handlebars';
-import { stringCamelCase } from '@pezkuwi/util';
-import { compareName, createImports, initMeta, readTemplate, writeFile } from '../util/index.js';
-import { getDeprecationNotice } from './types.js';
-const generateForMetaTemplate = Handlebars.compile(readTemplate('errors'));
-/** @internal */
-function generateForMeta(meta, dest, isStrict) {
-    writeFile(dest, () => {
-        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 = 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']
-                }
-            ]
-        });
-    });
-}
-/** @internal */
-export function generateDefaultErrors(dest, data, extraTypes = {}, isStrict = false) {
-    const { metadata } = initMeta(data, extraTypes);
-    return generateForMeta(metadata, dest, isStrict);
-}

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

@@ -1,135 +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, initMeta, readTemplate, rebrandTypeName, setImports, writeFile } from '../util/index.js';
-import { ignoreUnusedLookups } from './lookup.js';
-import { getDeprecationNotice } from './types.js';
-const generateForMetaTemplate = Handlebars.compile(readTemplate('events'));
-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, 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, registry } = meta.asLatest;
-        const usedTypes = new Set([]);
-        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 = 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);
-                    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: packagePath.replace('@pezkuwi/types-augment', '@pezkuwi/types'),
-                    types: Object.keys(imports.localTypes[packagePath])
-                })),
-                {
-                    file: '@pezkuwi/api-base/types',
-                    types: ['ApiTypes', 'AugmentedEvent']
-                }
-            ]
-        });
-    });
-}
-/** @internal */
-export function generateDefaultEvents(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
-    const { metadata } = initMeta(data, extraTypes);
-    return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
-}

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

@@ -1,59 +0,0 @@
-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, dest) {
-    const registry = new TypeRegistry();
-    writeFile(dest, () => {
-        Object.entries(importDefinitions).reduce((acc, def) => Object.assign(acc, def), {});
-        const imports = createImports(importDefinitions);
-        const definitions = imports.definitions;
-        const items = [];
-        // first we create imports for our known classes from the API
-        Object
-            .keys(primitiveClasses)
-            .filter((name) => !name.includes('Generic'))
-            .forEach((primitiveName) => {
-            setImports(definitions, imports, [primitiveName]);
-            items.push(primitiveName);
-        });
-        const existingTypes = {};
-        // 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);
-        });
-        // 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) => {
-                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: packagePath,
-                    types: Object.keys(imports.localTypes[packagePath])
-                }))
-            ]
-        });
-    });
-}
-export function generateDefaultInterface() {
-    generateInterfaceTypes({ '@pezkuwi/types/interfaces': defaultDefinitions }, 'packages/types-augment/src/registry/interfaces.ts');
-}