@pezkuwi/typegen 16.5.5 → 16.5.6

package/cjs/generate/events.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDefaultEvents = generateDefaultEvents;
+const tslib_1 = require("tslib");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+const defaultDefs = tslib_1.__importStar(require("@pezkuwi/types/interfaces/definitions"));
+const definitions_1 = tslib_1.__importDefault(require("@pezkuwi/types-augment/lookup/definitions"));
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const lookup_js_1 = require("./lookup.js");
+const types_js_1 = require("./types.js");
+const generateForMetaTemplate = handlebars_1.default.compile((0, index_js_1.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) {
+    (0, index_js_1.writeFile)(dest, () => {
+        const allTypes = {
+            '@pezkuwi/types-augment': {
+                lookup: {
+                    ...definitions_1.default,
+                    ...customLookupDefinitions
+                }
+            },
+            '@pezkuwi/types/interfaces': defaultDefs,
+            ...extraTypes
+        };
+        const imports = (0, index_js_1.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 = (0, types_js_1.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 = (0, index_js_1.rebrandTypeName)(typeDef.lookupName || '') || (0, index_js_1.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);
+                    (0, index_js_1.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(index_js_1.compareName),
+                name: (0, util_1.stringCamelCase)(name)
+            };
+        })
+            .sort(index_js_1.compareName);
+        // filter out the unused lookup types from imports
+        (0, lookup_js_1.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 */
+function generateDefaultEvents(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
+    const { metadata } = (0, index_js_1.initMeta)(data, extraTypes);
+    return generateForMeta(metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}

package/cjs/generate/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDefaultTx = exports.generateDefaultTsDef = exports.generateDefaultRuntime = exports.generateDefaultRpc = exports.generateDefaultQuery = exports.generateDefaultLookup = exports.generateDefaultInterface = exports.generateDefaultEvents = exports.generateDefaultErrors = exports.generateDefaultConsts = void 0;
+var consts_js_1 = require("./consts.js");
+Object.defineProperty(exports, "generateDefaultConsts", { enumerable: true, get: function () { return consts_js_1.generateDefaultConsts; } });
+var errors_js_1 = require("./errors.js");
+Object.defineProperty(exports, "generateDefaultErrors", { enumerable: true, get: function () { return errors_js_1.generateDefaultErrors; } });
+var events_js_1 = require("./events.js");
+Object.defineProperty(exports, "generateDefaultEvents", { enumerable: true, get: function () { return events_js_1.generateDefaultEvents; } });
+var interfaceRegistry_js_1 = require("./interfaceRegistry.js");
+Object.defineProperty(exports, "generateDefaultInterface", { enumerable: true, get: function () { return interfaceRegistry_js_1.generateDefaultInterface; } });
+var lookup_js_1 = require("./lookup.js");
+Object.defineProperty(exports, "generateDefaultLookup", { enumerable: true, get: function () { return lookup_js_1.generateDefaultLookup; } });
+var query_js_1 = require("./query.js");
+Object.defineProperty(exports, "generateDefaultQuery", { enumerable: true, get: function () { return query_js_1.generateDefaultQuery; } });
+var rpc_js_1 = require("./rpc.js");
+Object.defineProperty(exports, "generateDefaultRpc", { enumerable: true, get: function () { return rpc_js_1.generateDefaultRpc; } });
+var runtime_js_1 = require("./runtime.js");
+Object.defineProperty(exports, "generateDefaultRuntime", { enumerable: true, get: function () { return runtime_js_1.generateDefaultRuntime; } });
+var tsDef_js_1 = require("./tsDef.js");
+Object.defineProperty(exports, "generateDefaultTsDef", { enumerable: true, get: function () { return tsDef_js_1.generateDefaultTsDef; } });
+var tx_js_1 = require("./tx.js");
+Object.defineProperty(exports, "generateDefaultTx", { enumerable: true, get: function () { return tx_js_1.generateDefaultTx; } });

package/cjs/generate/interfaceRegistry.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterfaceTypes = generateInterfaceTypes;
+exports.generateDefaultInterface = generateDefaultInterface;
+const tslib_1 = require("tslib");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+const codec_1 = require("@pezkuwi/types/codec");
+const create_1 = require("@pezkuwi/types/create");
+const defaultDefinitions = tslib_1.__importStar(require("@pezkuwi/types/interfaces/definitions"));
+const defaultPrimitives = tslib_1.__importStar(require("@pezkuwi/types/primitive"));
+const index_js_1 = require("../util/index.js");
+const primitiveClasses = {
+    ...defaultPrimitives,
+    Json: codec_1.Json,
+    Raw: codec_1.Raw
+};
+const generateInterfaceTypesTemplate = handlebars_1.default.compile((0, index_js_1.readTemplate)('interfaceRegistry'));
+/** @internal */
+function generateInterfaceTypes(importDefinitions, dest) {
+    const registry = new create_1.TypeRegistry();
+    (0, index_js_1.writeFile)(dest, () => {
+        Object.entries(importDefinitions).reduce((acc, def) => Object.assign(acc, def), {});
+        const imports = (0, index_js_1.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) => {
+            (0, index_js_1.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 }) => {
+            (0, index_js_1.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])
+                }))
+            ]
+        });
+    });
+}
+function generateDefaultInterface() {
+    generateInterfaceTypes({ '@pezkuwi/types/interfaces': defaultDefinitions }, 'packages/types-augment/src/registry/interfaces.ts');
+}

package/cjs/generate/lookup.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDefaultLookup = generateDefaultLookup;
+exports.ignoreUnusedLookups = ignoreUnusedLookups;
+const tslib_1 = require("tslib");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const defaultDefinitions = tslib_1.__importStar(require("@pezkuwi/types/interfaces/definitions"));
+const asset_hub_dicle_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/asset-hub-dicle-hex"));
+const asset_hub_pezkuwi_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/asset-hub-pezkuwi-hex"));
+const dicle_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/dicle-hex"));
+const pezkuwi_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/pezkuwi-hex"));
+const bizinikiwi_hex_1 = tslib_1.__importDefault(require("@pezkuwi/types-support/metadata/v15/bizinikiwi-hex"));
+const util_1 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const tsDef_js_1 = require("./tsDef.js");
+function deepRebrandTypeDef(typeDef, isTopLevel = true) {
+    const rebrandedLookupName = typeDef.lookupName ? (0, index_js_1.rebrandTypeName)(typeDef.lookupName) : typeDef.lookupName;
+    const rebranded = {
+        ...typeDef,
+        type: (0, index_js_1.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 ? (0, index_js_1.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;
+}
+const WITH_TYPEDEF = false;
+const generateLookupDefsTmpl = handlebars_1.default.compile((0, index_js_1.readTemplate)('lookup/defs'));
+const generateLookupDefsNamedTmpl = handlebars_1.default.compile((0, index_js_1.readTemplate)('lookup/defs-named'));
+const generateLookupIndexTmpl = handlebars_1.default.compile((0, index_js_1.readTemplate)('lookup/index'));
+const generateLookupTypesTmpl = handlebars_1.default.compile((0, index_js_1.readTemplate)('lookup/types'));
+const generateRegistryTmpl = handlebars_1.default.compile((0, index_js_1.readTemplate)('interfaceRegistry'));
+function generateParamType(registry, { name, type }) {
+    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, id, path, params) {
+    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) {
+    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) {
+    return formatObject(Object.entries(parsed).reduce((all, [k, v]) => {
+        all.push(`${k}: ${v}`);
+        return all;
+    }, []));
+}
+function expandObject(parsed) {
+    if (parsed._set) {
+        return expandSet(parsed._set);
+    }
+    return formatObject(Object.entries(parsed).reduce((all, [k, v]) => {
+        const inner = (0, util_1.isString)(v)
+            ? expandType(v)
+            : Array.isArray(v)
+                ? [`[${v.map((e) => `'${e}'`).join(', ')}]`]
+                : expandObject(v);
+        inner.forEach((l, index) => {
+            all.push(`${index === 0
+                ? `${k}: ${l}`
+                : `${l}`}`);
+        });
+        return all;
+    }, []));
+}
+function expandType(encoded) {
+    if (!encoded.startsWith('{')) {
+        return [`'${(0, index_js_1.rebrandTypeName)(encoded)}'`];
+    }
+    return expandObject(JSON.parse(encoded));
+}
+function expandDefToString({ lookupNameRoot, type }, indent) {
+    if (lookupNameRoot) {
+        return `'${(0, index_js_1.rebrandTypeName)(lookupNameRoot)}'`;
+    }
+    const lines = expandType(type);
+    let inc = 0;
+    return lines.map((l, index) => {
+        let r;
+        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, exclude = []) {
+    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) => [p, lookup.getTypeDef(p.id)])
+        .filter(([, typeDef]) => !exclude.includes(typeDef.lookupName || '<invalid>'));
+}
+function generateLookupDefs(registry, filtered, destDir, subPath) {
+    (0, index_js_1.writeFile)(node_path_1.default.join(destDir, `${subPath || 'definitions'}.ts`), () => {
+        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 ${(0, util_1.stringify)(typeDef)}`
+                        : null
+                ].filter((d) => !!d),
+                type: { def, typeLookup, typeName: typeDef.lookupName ? (0, index_js_1.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, filtered, destDir, subPath) {
+    const imports = {
+        ...(0, index_js_1.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
+            ? (0, index_js_1.exportInterface)(rebranded.lookupIndex, rebranded.lookupName, rebranded.lookupNameRoot)
+            : tsDef_js_1.typeEncoders[rebranded.info](registry, imports.definitions, rebranded, imports);
+    })
+        .filter((t) => !!t)
+        .map((t) => t.replace(/\nexport /, '\n'));
+    (0, index_js_1.writeFile)(node_path_1.default.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: packagePath,
+                types: Object.keys(imports.localTypes[packagePath])
+            }))
+        ]
+    }), true);
+    (0, index_js_1.writeFile)(node_path_1.default.join(destDir, 'index.ts'), () => generateLookupIndexTmpl({ headerType: 'defs' }), true);
+}
+function generateRegistry(_registry, filtered, destDir, subPath) {
+    (0, index_js_1.writeFile)(node_path_1.default.join(destDir, `${subPath}.ts`), () => {
+        const items = filtered
+            .map(([, { lookupName }]) => lookupName ? (0, index_js_1.rebrandTypeName)(lookupName) : lookupName)
+            .filter((n) => !!n)
+            .sort()
+            .reduce((all, n) => all.includes(n) ? all : all.concat(n), []);
+        const imports = (0, index_js_1.createImports)({}, { types: {} });
+        imports.lookupTypes = items.reduce((all, n) => ({ ...all, [n]: true }), {});
+        return generateRegistryTmpl({
+            headerType: 'defs',
+            imports,
+            items,
+            types: []
+        });
+    }, true);
+}
+function generateLookup(destDir, entries) {
+    entries.reduce((exclude, [subPath, staticMeta]) => {
+        const { lookup, registry } = (0, index_js_1.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));
+    }, []);
+}
+function generateDefaultLookup(destDir = 'packages/types-augment/src/lookup', staticData) {
+    generateLookup(destDir, staticData
+        ? [['lookup', staticData]]
+        : [
+            ['bizinikiwi', bizinikiwi_hex_1.default],
+            ['pezkuwi', pezkuwi_hex_1.default],
+            ['dicle', dicle_hex_1.default],
+            ['assetHubPezkuwi', asset_hub_pezkuwi_hex_1.default],
+            ['assetHubDicle', asset_hub_dicle_hex_1.default]
+        ]);
+}
+function ignoreUnusedLookups(usedTypes, imports) {
+    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];
+        }
+    });
+}

package/cjs/generate/query.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDefaultQuery = generateDefaultQuery;
+const tslib_1 = require("tslib");
+const handlebars_1 = tslib_1.__importDefault(require("handlebars"));
+const defaultDefs = tslib_1.__importStar(require("@pezkuwi/types/interfaces/definitions"));
+const util_1 = require("@pezkuwi/types/util");
+const definitions_1 = tslib_1.__importDefault(require("@pezkuwi/types-augment/lookup/definitions"));
+const util_2 = require("@pezkuwi/util");
+const index_js_1 = require("../util/index.js");
+const lookup_js_1 = require("./lookup.js");
+const types_js_1 = require("./types.js");
+const generateForMetaTemplate = handlebars_1.default.compile((0, index_js_1.readTemplate)('query'));
+/** @internal */
+function entrySignature(lookup, allDefs, registry, section, storageEntry, imports) {
+    try {
+        const outputType = lookup.getTypeDef((0, util_1.unwrapStorageSi)(storageEntry.type));
+        if (storageEntry.type.isPlain) {
+            const typeDef = lookup.getTypeDef(storageEntry.type.asPlain);
+            (0, index_js_1.setImports)(allDefs, imports, [
+                (0, index_js_1.rebrandTypeName)(typeDef.lookupName || typeDef.type),
+                storageEntry.modifier.isOptional
+                    ? 'Option'
+                    : null
+            ]);
+            return [storageEntry.modifier.isOptional, '', '', (0, index_js_1.formatType)(registry, allDefs, outputType, imports)];
+        }
+        else if (storageEntry.type.isMap) {
+            const { hashers, key, value } = storageEntry.type.asMap;
+            const keyDefs = hashers.length === 1
+                ? [lookup.getTypeDef(key)]
+                : lookup.getSiType(key).def.asTuple.map((k) => lookup.getTypeDef(k));
+            const similarTypes = keyDefs.map((k) => (0, index_js_1.getSimilarTypes)(registry, allDefs, k.lookupName || k.type, imports));
+            const keyTypes = similarTypes.map((t) => t.join(' | '));
+            const defValue = lookup.getTypeDef(value);
+            (0, index_js_1.setImports)(allDefs, imports, [
+                ...similarTypes.reduce((all, t) => all.concat(t), []),
+                storageEntry.modifier.isOptional
+                    ? 'Option'
+                    : null,
+                (0, index_js_1.rebrandTypeName)(defValue.lookupName || defValue.type)
+            ]);
+            return [
+                storageEntry.modifier.isOptional,
+                keyDefs.map((k) => (0, index_js_1.formatType)(registry, allDefs, k.lookupName || k.type, imports)).join(', '),
+                keyTypes.map((t, i) => `arg${keyTypes.length === 1 ? '' : (i + 1)}: ${t}`).join(', '),
+                (0, index_js_1.rebrandTypeName)(outputType.lookupName || '') || (0, index_js_1.formatType)(registry, allDefs, outputType, imports)
+            ];
+        }
+        throw new Error(`Expected Plain or Map type, found ${storageEntry.type.type}`);
+    }
+    catch (error) {
+        throw new Error(`entrySignature: Cannot create signature for query ${section}.${storageEntry.name.toString()}:: ${error.message}`);
+    }
+}
+/** @internal */
+function generateForMeta(registry, meta, dest, extraTypes, isStrict, customLookupDefinitions) {
+    (0, index_js_1.writeFile)(dest, () => {
+        const allTypes = {
+            '@pezkuwi/types-augment': {
+                lookup: {
+                    ...definitions_1.default,
+                    ...customLookupDefinitions
+                }
+            },
+            '@pezkuwi/types/interfaces': defaultDefs,
+            ...extraTypes
+        };
+        const imports = (0, index_js_1.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 } = meta.asLatest;
+        const usedTypes = new Set([]);
+        const modules = pallets
+            .filter(({ storage }) => storage.isSome)
+            .map(({ name, storage }) => {
+            const items = storage.unwrap().items
+                .map((storageEntry) => {
+                const { deprecationInfo, docs, name } = storageEntry;
+                const [isOptional, args, params, _returnType] = entrySignature(lookup, allDefs, registry, name.toString(), storageEntry, imports);
+                if (!deprecationInfo.isNotDeprecated) {
+                    const deprecationNotice = (0, types_js_1.getDeprecationNotice)(deprecationInfo, (0, util_2.stringCamelCase)(name));
+                    const items = docs.length
+                        ? ['', deprecationNotice]
+                        : [deprecationNotice];
+                    docs.push(...items.map((text) => registry.createType('Text', text)));
+                }
+                // Add the type and args to the list of used types
+                if (!(imports.primitiveTypes[_returnType])) {
+                    usedTypes.add(_returnType);
+                }
+                if (!(imports.primitiveTypes[args])) {
+                    usedTypes.add(args);
+                }
+                const returnType = isOptional
+                    ? `Option<${_returnType}>`
+                    : _returnType;
+                return {
+                    args,
+                    docs,
+                    entryType: 'AugmentedQuery',
+                    name: (0, util_2.stringCamelCase)(storageEntry.name),
+                    params,
+                    returnType
+                };
+            })
+                .sort(index_js_1.compareName);
+            return {
+                items,
+                name: (0, util_2.stringCamelCase)(name)
+            };
+        })
+            .sort(index_js_1.compareName);
+        imports.typesTypes['Observable'] = true;
+        // filter out the unused lookup types from imports
+        (0, lookup_js_1.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', 'AugmentedQuery', 'QueryableStorageEntry']
+                }
+            ]
+        });
+    });
+}
+/** @internal */
+function generateDefaultQuery(dest, data, extraTypes = {}, isStrict = false, customLookupDefinitions) {
+    const { metadata, registry } = (0, index_js_1.initMeta)(data, extraTypes);
+    return generateForMeta(registry, metadata, dest, extraTypes, isStrict, customLookupDefinitions);
+}