@pezkuwi/typegen 16.5.5 → 16.5.6

package/cjs/util/wsMeta.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataViaWs = getMetadataViaWs;
+exports.getRpcMethodsViaWs = getRpcMethodsViaWs;
+exports.getRuntimeVersionViaWs = getRuntimeVersionViaWs;
+const decorateMethod_1 = require("@pezkuwi/api/promise/decorateMethod");
+const types_1 = require("@pezkuwi/types");
+const util_1 = require("@pezkuwi/util");
+const x_ws_1 = require("@pezkuwi/x-ws");
+async function getWsData(endpoint, method, params) {
+    return new Promise((resolve, reject) => {
+        const tracker = (0, decorateMethod_1.promiseTracker)(resolve, reject);
+        try {
+            const websocket = new x_ws_1.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:: ${(0, util_1.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);
+        }
+    });
+}
+async function getMetadataViaWs(endpoint, metadataVer) {
+    const registry = new types_1.TypeRegistry();
+    if (metadataVer) {
+        return await getWsData(endpoint, 'state_call', ['Metadata_metadata_at_version', (0, util_1.u8aToHex)(registry.createType('u32', metadataVer).toU8a())]);
+    }
+    else {
+        return await getWsData(endpoint, 'state_getMetadata');
+    }
+}
+async function getRpcMethodsViaWs(endpoint) {
+    const result = await getWsData(endpoint, 'rpc_methods');
+    return result.methods;
+}
+async function getRuntimeVersionViaWs(endpoint) {
+    const result = await getWsData(endpoint, 'state_getRuntimeVersion');
+    return result.apis;
+}

package/extractChain.d.ts

@@ -0,0 +1 @@
+export declare function main(): void;

package/extractChain.js

@@ -0,0 +1,40 @@
+import process from 'node:process';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { ApiPromise, WsProvider } from '@pezkuwi/api';
+/** @internal */
+async function run(ws) {
+    const provider = new WsProvider(ws);
+    const api = await ApiPromise.create({ provider, throwOnConnect: true });
+    const [chain, props] = await Promise.all([
+        api.rpc.system.chain(),
+        api.rpc.system.properties()
+    ]);
+    // output the chain info, for easy re-use
+    console.error(`// Generated via 'yarn run chain:info ${ws}'\n\nexport default {\n  chain: '${chain.toString()}',\n  genesisHash: '${api.genesisHash.toHex()}',\n  specVersion: ${api.runtimeVersion.specVersion.toNumber()},\n  ss58Format: ${props.ss58Format.unwrapOr(42).toString()},\n  tokenDecimals: ${props.tokenDecimals.unwrapOr(0).toString()},\n  tokenSymbol: '${props.tokenSymbol.unwrapOr('UNIT').toString()}',\n  metaCalls: '${Buffer.from(api.runtimeMetadata.asCallsOnly.toU8a()).toString('base64')}'\n};`);
+    // show any missing types
+    api.runtimeMetadata.getUniqTypes(false);
+}
+export function main() {
+    // retrieve and parse arguments - we do this globally, since this is a single command
+    const { ws } = yargs(hideBin(process.argv))
+        .usage('Usage: [options]')
+        .wrap(120)
+        .strict()
+        .options({
+        ws: {
+            default: 'ws://127.0.0.1:9944',
+            description: 'The API endpoint to connect to, e.g. wss://dicle-rpc.pezkuwi.io',
+            required: true,
+            type: 'string'
+        }
+    }).argv;
+    run(ws)
+        .then(() => {
+        process.exit(0);
+    })
+        .catch((error) => {
+        console.error('FATAL:', error.message);
+        process.exit(-1);
+    });
+}

package/fromChain.d.ts

@@ -0,0 +1 @@
+export declare function main(): void;

package/fromChain.js

@@ -0,0 +1,91 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { formatNumber, isHex } from '@pezkuwi/util';
+import { generateDefaultConsts, generateDefaultErrors, generateDefaultEvents, generateDefaultQuery, generateDefaultRpc, generateDefaultRuntime, generateDefaultTx } from './generate/index.js';
+import { assertDir, assertFile, getMetadataViaWs, HEADER, writeFile } from './util/index.js';
+async function generate(metaHex, pkg, output, isStrict) {
+    console.log(`Generating from metadata, ${formatNumber((metaHex.length - 2) / 2)} bytes`);
+    const outputPath = assertDir(path.join(process.cwd(), output));
+    let extraTypes = {};
+    let customLookupDefinitions = { rpc: {}, types: {} };
+    if (pkg) {
+        try {
+            const defCont = await import(assertFile(path.join(outputPath, 'definitions.ts')));
+            extraTypes = {
+                [pkg]: defCont
+            };
+        }
+        catch (error) {
+            console.error('ERROR: No custom definitions found:', error.message);
+        }
+    }
+    try {
+        const lookCont = await import(assertFile(path.join(outputPath, 'lookup.ts')));
+        customLookupDefinitions = {
+            rpc: {},
+            types: lookCont.default
+        };
+    }
+    catch (error) {
+        console.error('ERROR: No lookup definitions found:', error.message);
+    }
+    generateDefaultConsts(path.join(outputPath, 'augment-api-consts.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
+    generateDefaultErrors(path.join(outputPath, 'augment-api-errors.ts'), metaHex, extraTypes, isStrict);
+    generateDefaultEvents(path.join(outputPath, 'augment-api-events.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
+    generateDefaultQuery(path.join(outputPath, 'augment-api-query.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
+    generateDefaultRpc(path.join(outputPath, 'augment-api-rpc.ts'), extraTypes);
+    generateDefaultRuntime(path.join(outputPath, 'augment-api-runtime.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
+    generateDefaultTx(path.join(outputPath, 'augment-api-tx.ts'), metaHex, extraTypes, isStrict, customLookupDefinitions);
+    writeFile(path.join(outputPath, 'augment-api.ts'), () => [
+        HEADER('chain'),
+        ...[
+            ...['consts', 'errors', 'events', 'query', 'tx', 'rpc', 'runtime']
+                .filter((key) => !!key)
+                .map((key) => `./augment-api-${key}.js`)
+        ].map((path) => `import '${path}';\n`)
+    ].join(''));
+    process.exit(0);
+}
+async function mainPromise() {
+    const { endpoint, output, package: pkg, strict: isStrict } = yargs(hideBin(process.argv)).strict().options({
+        endpoint: {
+            description: 'The endpoint to connect to (e.g. wss://dicle-rpc.pezkuwi.io) or relative path to a file containing the JSON output of an RPC state_getMetadata call',
+            required: true,
+            type: 'string'
+        },
+        output: {
+            description: 'The target directory to write the data to',
+            required: true,
+            type: 'string'
+        },
+        package: {
+            description: 'Optional package in output location (for extra definitions)',
+            type: 'string'
+        },
+        strict: {
+            description: 'Turns on strict mode, no output of catch-all generic versions',
+            type: 'boolean'
+        }
+    }).argv;
+    let metaHex;
+    if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
+        metaHex = await getMetadataViaWs(endpoint);
+    }
+    else {
+        metaHex = JSON.parse(fs.readFileSync(assertFile(path.join(process.cwd(), endpoint)), 'utf-8')).result;
+        if (!isHex(metaHex)) {
+            throw new Error('Invalid metadata file');
+        }
+    }
+    await generate(metaHex, pkg, output, isStrict);
+}
+export function main() {
+    mainPromise().catch((error) => {
+        console.error();
+        console.error(error);
+        console.error();
+        process.exit(1);
+    });
+}

package/fromDefs.d.ts

@@ -0,0 +1 @@
+export declare function main(): void;

package/fromDefs.js

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import * as bizinikiwiDefs from '@pezkuwi/types/interfaces/definitions';
+import { isHex } from '@pezkuwi/util';
+import { generateDefaultLookup } from './generate/index.js';
+import { generateInterfaceTypes } from './generate/interfaceRegistry.js';
+import { generateTsDef } from './generate/tsDef.js';
+import { assertDir, assertFile, getMetadataViaWs } from './util/index.js';
+async function mainPromise() {
+    const { endpoint, input, package: pkg } = yargs(hideBin(process.argv)).strict().options({
+        endpoint: {
+            description: 'The endpoint to connect to (e.g. wss://dicle-rpc.pezkuwi.io) or relative path to a file containing the JSON output of an RPC state_getMetadata call',
+            type: 'string'
+        },
+        input: {
+            description: 'The directory to use for the user definitions',
+            required: true,
+            type: 'string'
+        },
+        package: {
+            description: 'The package name & path to use for the user types',
+            required: true,
+            type: 'string'
+        }
+    }).argv;
+    const inputPath = assertDir(path.join(process.cwd(), input));
+    let userDefs = {};
+    try {
+        const defCont = await import(assertFile(path.join(inputPath, 'definitions.ts')));
+        userDefs = defCont;
+    }
+    catch (error) {
+        console.error('ERROR: Unable to load user definitions:', error.message);
+    }
+    const userKeys = Object.keys(userDefs);
+    const filteredBase = Object
+        .entries(bizinikiwiDefs)
+        .filter(([key]) => {
+        if (userKeys.includes(key)) {
+            console.warn(`Override found for ${key} in user types, ignoring in @pezkuwi/types`);
+            return false;
+        }
+        return true;
+    })
+        .reduce((defs, [key, value]) => {
+        defs[key] = value;
+        return defs;
+    }, {});
+    const allDefs = {
+        '@pezkuwi/types/interfaces': filteredBase,
+        [pkg]: userDefs
+    };
+    generateTsDef(allDefs, inputPath, pkg);
+    generateInterfaceTypes(allDefs, path.join(inputPath, 'augment-types.ts'));
+    if (endpoint) {
+        let metaHex;
+        if (endpoint.startsWith('wss://') || endpoint.startsWith('ws://')) {
+            metaHex = await getMetadataViaWs(endpoint);
+        }
+        else {
+            metaHex = JSON.parse(fs.readFileSync(assertFile(path.join(process.cwd(), endpoint)), 'utf-8')).result;
+            if (!isHex(metaHex)) {
+                throw new Error('Invalid metadata file');
+            }
+        }
+        generateDefaultLookup(inputPath, metaHex);
+    }
+}
+export function main() {
+    mainPromise().catch((error) => {
+        console.error();
+        console.error(error);
+        console.error();
+        process.exit(1);
+    });
+}

package/generate/consts.d.ts

@@ -0,0 +1,5 @@
+import type { Definitions } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import { type ExtraTypes } from './types.js';
+/** @internal */
+export declare function generateDefaultConsts(dest: string, data: HexString, extraTypes?: ExtraTypes, isStrict?: boolean, customLookupDefinitions?: Definitions): void;

package/generate/consts.js

@@ -0,0 +1,87 @@
+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/generate/errors.d.ts

@@ -0,0 +1,4 @@
+import type { HexString } from '@pezkuwi/util/types';
+import { type ExtraTypes } from './types.js';
+/** @internal */
+export declare function generateDefaultErrors(dest: string, data: HexString, extraTypes?: ExtraTypes, isStrict?: boolean): void;

package/generate/errors.js

@@ -0,0 +1,55 @@
+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/generate/events.d.ts

@@ -0,0 +1,5 @@
+import type { Definitions } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import { type ExtraTypes } from './types.js';
+/** @internal */
+export declare function generateDefaultEvents(dest: string, data: HexString, extraTypes?: ExtraTypes, isStrict?: boolean, customLookupDefinitions?: Definitions): void;

package/generate/events.js

@@ -0,0 +1,135 @@
+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/{src/generate/index.ts → generate/index.d.ts}

@@ -1,6 +1,3 @@
-// Copyright 2017-2025 @polkadot/typegen authors & contributors
-// SPDX-License-Identifier: Apache-2.0
-
 export { generateDefaultConsts } from './consts.js';
 export { generateDefaultErrors } from './errors.js';
 export { generateDefaultEvents } from './events.js';

package/generate/index.js

@@ -0,0 +1,10 @@
+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/generate/interfaceRegistry.d.ts

@@ -0,0 +1,4 @@
+import type { ModuleTypes } from '../util/imports.js';
+/** @internal */
+export declare function generateInterfaceTypes(importDefinitions: Record<string, Record<string, ModuleTypes>>, dest: string): void;
+export declare function generateDefaultInterface(): void;

package/generate/interfaceRegistry.js

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