@pezkuwi/typegen 16.5.18 → 16.5.31

package/build/templates/errors.hbs

@@ -1,28 +0,0 @@
-{{> header }}
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@pezkuwi/api-base/types/errors';
-
-{{{ importsAll }}}
-
-export type __AugmentedError<ApiType extends ApiTypes> = AugmentedError<ApiType>;
-
-declare module '@pezkuwi/api-base/types/errors' {
-  interface AugmentedErrors<ApiType extends ApiTypes> {
-    {{#each modules}}
-    {{{name}}}: {
-      {{#each items}}
-      {{> docs}}
-      {{{name}}}: AugmentedError<ApiType>;
-      {{/each}}
-      {{#unless @root.isStrict}}
-      /**
-       * Generic error
-       **/
-      [key: string]: AugmentedError<ApiType>;
-      {{/unless}}
-    };
-    {{/each}}
-  } // AugmentedErrors
-} // declare module

package/build/templates/events.hbs

@@ -1,28 +0,0 @@
-{{> header }}
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@pezkuwi/api-base/types/events';
-
-{{{ importsAll }}}
-
-export type __AugmentedEvent<ApiType extends ApiTypes> = AugmentedEvent<ApiType>;
-
-declare module '@pezkuwi/api-base/types/events' {
-  interface AugmentedEvents<ApiType extends ApiTypes> {
-    {{#each modules}}
-    {{{name}}}: {
-      {{#each items}}
-      {{> docs}}
-      {{{name}}}: AugmentedEvent<ApiType, {{{type}}}>;
-      {{/each}}
-      {{#unless @root.isStrict}}
-      /**
-       * Generic event
-       **/
-      [key: string]: AugmentedEvent<ApiType>;
-      {{/unless}}
-    };
-    {{/each}}
-  } // AugmentedEvents
-} // declare module

package/build/templates/header.hbs

@@ -1,2 +0,0 @@
-// Auto-generated via `yarn polkadot-types-from-{{headerType}}`, do not edit
-/* eslint-disable */

package/build/templates/interfaceRegistry.hbs

@@ -1,15 +0,0 @@
-{{> header }}
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@pezkuwi/types/types/registry';
-
-{{{ importsAll }}}
-
-declare module '@pezkuwi/types/types/registry' {
-  interface InterfaceTypes {
-    {{#each items}}
-    {{{this}}}: {{{this}}};
-    {{/each}}
-  } // InterfaceTypes
-} // declare module

package/build/templates/lookup/defs-named.hbs

@@ -1,12 +0,0 @@
-{{> header }}
-
-/* eslint-disable sort-keys */
-
-export default {
-  {{#each defs}}
-  {{> docs}}
-  {{#each defs}}
-  {{{this}}}
-  {{/each}}
-  {{/each}}
-};

package/build/templates/lookup/defs.hbs

@@ -1,15 +0,0 @@
-{{> header }}
-
-/* eslint-disable sort-keys */
-
-export default {
-  rpc: {},
-  types: {
-    {{#each defs}}
-    {{> docs}}
-    {{#each defs}}
-    {{{this}}}
-    {{/each}}
-    {{/each}}
-  }
-};

package/build/templates/lookup/index.hbs

@@ -1,3 +0,0 @@
-{{> header }}
-
-export * from './types.js';

package/build/templates/lookup/types.hbs

@@ -1,14 +0,0 @@
-{{> header }}
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@pezkuwi/types/lookup';
-
-{{{ importsAll }}}
-
-declare module '@pezkuwi/types/lookup' {
-  {{#each items}}
-{{{this}}}
-
-  {{/each}}
-} // declare module

package/build/templates/query.hbs

@@ -1,29 +0,0 @@
-{{> header }}
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@pezkuwi/api-base/types/storage';
-
-{{{ importsAll }}}
-
-export type __AugmentedQuery<ApiType extends ApiTypes> = AugmentedQuery<ApiType, () => unknown>;
-export type __QueryableStorageEntry<ApiType extends ApiTypes> = QueryableStorageEntry<ApiType>;
-
-declare module '@pezkuwi/api-base/types/storage' {
-  interface AugmentedQueries<ApiType extends ApiTypes> {
-    {{#each modules}}
-    {{{name}}}: {
-      {{#each items}}
-      {{> docs}}
-      {{{name}}}: {{{entryType}}}<ApiType, ({{{params}}}) => Observable<{{{returnType}}}>, [{{{args}}}]>{{#unless @root.isStrict}} & QueryableStorageEntry<ApiType, [{{{args}}}]>{{/unless}};
-      {{/each}}
-      {{#unless @root.isStrict}}
-      /**
-       * Generic query
-       **/
-      [key: string]: QueryableStorageEntry<ApiType>;
-      {{/unless}}
-    };
-    {{/each}}
-  } // AugmentedQueries
-} // declare module

package/build/templates/rpc.hbs

@@ -1,22 +0,0 @@
-{{> header }}
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@pezkuwi/rpc-core/types/jsonrpc';
-
-{{{ importsAll }}}
-
-export type __AugmentedRpc = AugmentedRpc<() => unknown>;
-
-declare module '@pezkuwi/rpc-core/types/jsonrpc' {
-  interface RpcInterface {
-    {{#each modules}}
-    {{{name}}}: {
-      {{#each items}}
-      {{> docs}}
-      {{{name}}}: AugmentedRpc<{{#if generic}}<{{{generic}}}>{{/if}}({{{args}}}) => Observable<{{{type}}}>>;
-      {{/each}}
-    };
-    {{/each}}
-  } // RpcInterface
-} // declare module

package/build/templates/tsDef/index.hbs

@@ -1,3 +0,0 @@
-{{> header }}
-
-export * from './types.js';

package/build/templates/tsDef/moduleTypes.hbs

@@ -1,10 +0,0 @@
-{{> header }}
-
-{{{ importsAll }}}
-
-{{#each items}}
-{{{this}}}
-
-{{/each}}
-
-export type PHANTOM_{{#upper}}{{{name}}}{{/upper}} = '{{{name}}}';

package/build/templates/tsDef/types.hbs

@@ -1,7 +0,0 @@
-{{> header }}
-
-{{#each items}}
-export * from './{{{this}}}/types.js';
-{{/each}}
-
-export type PHANTOM_GENERATED = 'generated';

package/build/templates/tx.hbs

@@ -1,30 +0,0 @@
-{{> header }}
-
-// import type lookup before we augment - in some environments
-// this is required to allow for ambient/previous definitions
-import '@pezkuwi/api-base/types/submittable';
-
-{{{ importsAll }}}
-
-export type __AugmentedSubmittable = AugmentedSubmittable<() => unknown>;
-export type __SubmittableExtrinsic<ApiType extends ApiTypes> = SubmittableExtrinsic<ApiType>;
-export type __SubmittableExtrinsicFunction<ApiType extends ApiTypes> = SubmittableExtrinsicFunction<ApiType>;
-
-declare module '@pezkuwi/api-base/types/submittable' {
-  interface AugmentedSubmittables<ApiType extends ApiTypes> {
-    {{#each modules}}
-    {{{name}}}: {
-      {{#each items}}
-      {{> docs}}
-      {{{name}}}: AugmentedSubmittable<({{{params}}}) => SubmittableExtrinsic<ApiType>, [{{{args}}}]>;
-      {{/each}}
-      {{#unless @root.isStrict}}
-      /**
-       * Generic tx
-       **/
-      [key: string]: SubmittableExtrinsicFunction<ApiType>;
-      {{/unless}}
-    };
-    {{/each}}
-  } // AugmentedSubmittables
-} // declare module

package/build/util/assert.d.ts

@@ -1,2 +0,0 @@
-export declare function assertDir(path: string): string;
-export declare function assertFile(path: string): string;

package/build/util/assert.js

@@ -1,10 +0,0 @@
-import fs from 'node:fs';
-import { assert } from '@pezkuwi/util';
-export function assertDir(path) {
-    assert(fs.existsSync(path) && fs.lstatSync(path).isDirectory(), `${path} is not a directory`);
-    return path;
-}
-export function assertFile(path) {
-    assert(fs.existsSync(path) && fs.lstatSync(path).isFile(), `${path} is not a file`);
-    return path;
-}

package/build/util/derived.d.ts

@@ -1,4 +0,0 @@
-import type { Registry } from '@pezkuwi/types/types';
-import type { ModuleTypes, TypeImports } from './imports.js';
-/** @internal */
-export declare function getSimilarTypes(registry: Registry, definitions: Record<string, ModuleTypes>, _type: string, imports: TypeImports): string[];

package/build/util/docs.d.ts

@@ -1 +0,0 @@
-export declare const __TYPEGEN_DUMMY_DOCS = "DUMMY_DOCS";

package/build/util/docs.js

@@ -1,6 +0,0 @@
-import Handlebars from 'handlebars';
-import { readTemplate } from './file.js';
-Handlebars.registerPartial({
-    docs: Handlebars.compile(readTemplate('docs'))
-});
-export const __TYPEGEN_DUMMY_DOCS = 'DUMMY_DOCS';

package/build/util/file.d.ts

@@ -1,2 +0,0 @@
-export declare function writeFile(dest: string, generator: () => string, noLog?: boolean): void;
-export declare function readTemplate(template: string): string;

package/build/util/file.js

@@ -1,28 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import process from 'node:process';
-import { packageInfo } from '../packageInfo.js';
-export function writeFile(dest, generator, noLog) {
-    !noLog && console.log(`${dest}\n\tGenerating`);
-    let generated = generator();
-    while (generated.includes('\n\n\n')) {
-        generated = generated.replace(/\n\n\n/g, '\n\n');
-    }
-    !noLog && console.log('\tWriting');
-    fs.writeFileSync(dest, generated, { flag: 'w' });
-    !noLog && console.log('');
-}
-export function readTemplate(template) {
-    // Inside the api repo itself, it will be 'auto'
-    const rootDir = packageInfo.path === 'auto'
-        ? path.join(process.cwd(), 'packages/typegen/src')
-        : packageInfo.path;
-    // NOTE With cjs in a subdir, search one lower as well
-    const file = ['./templates', '../templates']
-        .map((p) => path.join(rootDir, p, `${template}.hbs`))
-        .find((p) => fs.existsSync(p));
-    if (!file) {
-        throw new Error(`Unable to locate ${template}.hbs from ${rootDir}`);
-    }
-    return fs.readFileSync(file).toString();
-}

package/build/util/formatting.d.ts

@@ -1,11 +0,0 @@
-import type { AnyString, Registry } from '@pezkuwi/types/types';
-import type { TypeDef } from '@pezkuwi/types-create/types';
-import type { ModuleTypes, TypeImports } from './imports.js';
-export declare const HEADER: (type: "chain" | "defs") => string;
-/** @internal */
-export declare function exportInterface(lookupIndex: number | undefined, name: string | undefined, base: string, body?: string, withShortcut?: boolean): string;
-/**
- * Correctly format a given type
- */
-/** @internal */
-export declare function formatType(registry: Registry, definitions: Record<string, ModuleTypes>, type: AnyString | TypeDef, imports: TypeImports, withShortcut?: boolean): string;

package/build/util/formatting.js

@@ -1,230 +0,0 @@
-import Handlebars from 'handlebars';
-import * as typesCodec from '@pezkuwi/types-codec';
-import { getTypeDef, paramsNotation, TypeDefInfo } from '@pezkuwi/types-create';
-import { isString, stringify } from '@pezkuwi/util';
-import { readTemplate } from './file.js';
-import { setImports } from './imports.js';
-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');
-}
-const NO_CODEC = ['Tuple', 'VecFixed'];
-const ON_CODEC = Object.keys(typesCodec);
-const ON_CODEC_TYPES = ['Codec', 'AnyJson', 'AnyFunction', 'AnyNumber', 'AnyString', 'AnyTuple', 'AnyU8a', 'ICompact', 'IEnum', 'IMap', 'INumber', 'IOption', 'IResult', 'ISet', 'IStruct', 'ITuple', 'IU8a', 'IVec', 'IMethod'];
-export const HEADER = (type) => `// Auto-generated via \`yarn pezkuwi-types-from-${type}\`, do not edit\n/* eslint-disable */\n\n`;
-function extractImports({ imports, types }) {
-    const toplevel = [
-        ...Object.keys(imports.codecTypes),
-        ...Object.keys(imports.extrinsicTypes),
-        ...Object.keys(imports.genericTypes),
-        ...Object.keys(imports.metadataTypes),
-        ...Object.keys(imports.primitiveTypes)
-    ];
-    return [
-        {
-            file: '@pezkuwi/types',
-            types: toplevel.filter((n) => !NO_CODEC.includes(n) && !ON_CODEC.includes(n))
-        },
-        {
-            file: '@pezkuwi/types/lookup',
-            types: Object.keys(imports.lookupTypes)
-        },
-        {
-            file: '@pezkuwi/types/types',
-            types: Object.keys(imports.typesTypes).filter((n) => !ON_CODEC_TYPES.includes(n))
-        },
-        {
-            file: '@pezkuwi/types-codec',
-            types: toplevel.filter((n) => !NO_CODEC.includes(n) && ON_CODEC.includes(n))
-        },
-        {
-            file: '@pezkuwi/types-codec/types',
-            types: Object.keys(imports.typesTypes).filter((n) => ON_CODEC_TYPES.includes(n))
-        },
-        ...types
-    ]
-        .filter(({ types }) => types.length)
-        .sort(({ file }, b) => file.localeCompare(b.file))
-        .map(({ file, types }) => `import type { ${types.sort().join(', ')} } from '${file}';`);
-}
-Handlebars.registerPartial({
-    header: Handlebars.compile(readTemplate('header'))
-});
-Handlebars.registerHelper({
-    importsAll() {
-        return extractImports(this)
-            .join('\n');
-    },
-    importsPackage() {
-        return extractImports(this)
-            .filter((l) => !l.includes("from '."))
-            .join('\n  ');
-    },
-    importsRelative() {
-        return extractImports(this)
-            .filter((l) => l.includes("from '."))
-            .join('\n');
-    },
-    trim(options) {
-        return options.fn(this).trim();
-    },
-    upper(options) {
-        return options.fn(this).toUpperCase();
-    }
-});
-/** @internal */
-export function exportInterface(lookupIndex = -1, name = '', base, body = '', withShortcut = false) {
-    // * @description extends [[${base}]]
-    const doc = withShortcut
-        ? ''
-        : `/** @name ${name}${lookupIndex !== -1 ? ` (${lookupIndex})` : ''} */\n`;
-    return `${doc}${withShortcut ? '' : `export interface ${name} extends ${base} `}{${body.length ? '\n' : ''}${body}${withShortcut ? '  ' : ''}}`;
-}
-function singleParamNotation(registry, wrapper, typeDef, definitions, imports, withShortcut) {
-    const sub = typeDef.sub;
-    const lookupName = rebrandTypeName(sub.lookupName || '');
-    setImports(definitions, imports, [wrapper, lookupName]);
-    return paramsNotation(wrapper, lookupName || formatType(registry, definitions, sub.type, imports, withShortcut));
-}
-function dualParamsNotation(registry, wrapper, typeDef, definitions, imports, withShortcut) {
-    const [a, b] = typeDef.sub;
-    const aLookupName = rebrandTypeName(a.lookupName || '');
-    const bLookupName = rebrandTypeName(b.lookupName || '');
-    setImports(definitions, imports, [wrapper, aLookupName, bLookupName]);
-    return paramsNotation(wrapper, [
-        aLookupName || formatType(registry, definitions, a.type, imports, withShortcut),
-        bLookupName || formatType(registry, definitions, b.type, imports, withShortcut)
-    ]);
-}
-const formatters = {
-    [TypeDefInfo.Compact]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'Compact', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.DoNotConstruct]: (_registry, _typeDef, definitions, imports, _withShortcut) => {
-        setImports(definitions, imports, ['DoNotConstruct']);
-        return 'DoNotConstruct';
-    },
-    [TypeDefInfo.Enum]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
-        if (typeDef.lookupName) {
-            return rebrandTypeName(typeDef.lookupName);
-        }
-        throw new Error(`TypeDefInfo.Enum: Parameter formatting not implemented on ${stringify(typeDef)}`);
-    },
-    [TypeDefInfo.Int]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
-        throw new Error(`TypeDefInfo.Int: Parameter formatting not implemented on ${stringify(typeDef)}`);
-    },
-    [TypeDefInfo.UInt]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
-        throw new Error(`TypeDefInfo.UInt: Parameter formatting not implemented on ${stringify(typeDef)}`);
-    },
-    [TypeDefInfo.Null]: (_registry, _typeDef, definitions, imports, _withShortcut) => {
-        setImports(definitions, imports, ['Null']);
-        return 'Null';
-    },
-    [TypeDefInfo.Option]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'Option', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.Plain]: (_registry, typeDef, definitions, imports, _withShortcut) => {
-        setImports(definitions, imports, [rebrandTypeName(typeDef.type)]);
-        return rebrandTypeName(typeDef.type);
-    },
-    [TypeDefInfo.Range]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'Range', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.RangeInclusive]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'RangeInclusive', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.Set]: (_registry, typeDef, _definitions, _imports, _withShortcut) => {
-        throw new Error(`TypeDefInfo.Set: Parameter formatting not implemented on ${stringify(typeDef)}`);
-    },
-    [TypeDefInfo.Si]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return formatType(registry, definitions, registry.lookup.getTypeDef(typeDef.type), imports, withShortcut);
-    },
-    [TypeDefInfo.Struct]: (registry, typeDef, definitions, imports, withShortcut) => {
-        if (typeDef.lookupName) {
-            return rebrandTypeName(typeDef.lookupName);
-        }
-        const sub = typeDef.sub;
-        setImports(definitions, imports, ['Struct', ...sub.map(({ lookupName }) => rebrandTypeName(lookupName || ''))]);
-        return `{${withShortcut ? ' ' : '\n'}${sub.map(({ lookupName, name, type }, index) => [
-            name || `unknown${index}`,
-            rebrandTypeName(lookupName || '') || formatType(registry, definitions, type, imports, withShortcut)
-        ]).map(([k, t]) => `${withShortcut ? '' : '    readonly '}${k}: ${t};`).join(withShortcut ? ' ' : '\n')}${withShortcut ? ' ' : '\n  '}} & Struct`;
-    },
-    [TypeDefInfo.Tuple]: (registry, typeDef, definitions, imports, withShortcut) => {
-        const sub = typeDef.sub;
-        setImports(definitions, imports, ['ITuple', ...sub.map(({ lookupName }) => rebrandTypeName(lookupName || ''))]);
-        // `(a,b)` gets transformed into `ITuple<[a, b]>`
-        return paramsNotation('ITuple', `[${sub.map(({ lookupName, type }) => rebrandTypeName(lookupName || '') || formatType(registry, definitions, type, imports, withShortcut)).join(', ')}]`);
-    },
-    [TypeDefInfo.Vec]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.VecFixed]: (registry, typeDef, definitions, imports, withShortcut) => {
-        const sub = typeDef.sub;
-        if (sub.type === 'u8') {
-            setImports(definitions, imports, ['U8aFixed']);
-            return 'U8aFixed';
-        }
-        return singleParamNotation(registry, 'Vec', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.BTreeMap]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return dualParamsNotation(registry, 'BTreeMap', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.BTreeSet]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'BTreeSet', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.HashMap]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return dualParamsNotation(registry, 'HashMap', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.Linkage]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'Linkage', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.Result]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return dualParamsNotation(registry, 'Result', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.WrapperKeepOpaque]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'WrapperKeepOpaque', typeDef, definitions, imports, withShortcut);
-    },
-    [TypeDefInfo.WrapperOpaque]: (registry, typeDef, definitions, imports, withShortcut) => {
-        return singleParamNotation(registry, 'WrapperOpaque', typeDef, definitions, imports, withShortcut);
-    }
-};
-/**
- * Correctly format a given type
- */
-/** @internal */
-export function formatType(registry, definitions, type, imports, withShortcut = false) {
-    let typeDef;
-    if (isString(type)) {
-        const _type = type.toString();
-        // If type is "unorthodox" (i.e. `{ something: any }` for an Enum input or `[a | b | c, d | e | f]` for a Tuple's similar types),
-        // we return it as-is
-        if (withShortcut && /(^{.+:.+})|^\([^,]+\)|^\(.+\)\[\]|^\[.+\]/.exec(_type) && !/\[\w+;\w+\]/.exec(_type)) {
-            return rebrandTypeName(_type);
-        }
-        typeDef = getTypeDef(type);
-    }
-    else {
-        typeDef = type;
-    }
-    setImports(definitions, imports, [rebrandTypeName(typeDef.lookupName || typeDef.type)]);
-    return rebrandTypeName(formatters[typeDef.info](registry, typeDef, definitions, imports, withShortcut));
-}

package/build/util/imports.d.ts

@@ -1,23 +0,0 @@
-export interface ModuleTypes {
-    types: Record<string, unknown>;
-}
-type TypeExist = Record<string, boolean>;
-type TypeExistMap = Record<string, TypeExist>;
-export interface TypeImports {
-    codecTypes: TypeExist;
-    extrinsicTypes: TypeExist;
-    genericTypes: TypeExist;
-    ignoredTypes: string[];
-    localTypes: TypeExistMap;
-    lookupTypes: TypeExistMap;
-    primitiveTypes: TypeExist;
-    metadataTypes: TypeExist;
-    typesTypes: TypeExist;
-    definitions: Record<string, ModuleTypes>;
-    typeToModule: Record<string, string>;
-}
-/** @internal */
-export declare function setImports(allDefs: Record<string, ModuleTypes>, imports: TypeImports, types: (string | null | undefined)[]): void;
-/** @internal */
-export declare function createImports(importDefinitions: Record<string, Record<string, ModuleTypes>>, { types }?: ModuleTypes): TypeImports;
-export {};