@pezkuwi/typegen 16.5.5

package/README.md

@@ -0,0 +1,3 @@
+# @pezkuwi/typegen
+
+A collection of type generation scripts, allowing the input of metadata and definitions for the creation of TS outputs.

package/build/augment.d.ts

@@ -0,0 +1,2 @@
+import '@pezkuwi/api-augment';
+import '@pezkuwi/rpc-augment';

package/build/bundle.d.ts

@@ -0,0 +1,2 @@
+export { packageInfo } from './packageInfo.js';
+export { formatType } from './util/formatting.js';

package/build/extractChain.d.ts

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

package/build/fromChain.d.ts

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

package/build/fromDefs.d.ts

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

package/build/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/build/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/build/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/build/generate/index.d.ts

@@ -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/build/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/build/generate/lookup.d.ts

@@ -0,0 +1,4 @@
+import type { HexString } from '@pezkuwi/util/types';
+import { type TypeImports } from '../util/index.js';
+export declare function generateDefaultLookup(destDir?: string, staticData?: HexString): void;
+export declare function ignoreUnusedLookups(usedTypes: string[], imports: TypeImports): void;

package/build/generate/query.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 generateDefaultQuery(dest: string, data: HexString, extraTypes?: ExtraTypes, isStrict?: boolean, customLookupDefinitions?: Definitions): void;

package/build/generate/rpc.d.ts

@@ -0,0 +1,6 @@
+import type { TypeRegistry } from '@pezkuwi/types/create';
+import type { Definitions } from '@pezkuwi/types/types';
+import type { ExtraTypes } from './types.js';
+/** @internal */
+export declare function generateRpcTypes(registry: TypeRegistry, importDefinitions: Record<string, Definitions>, dest: string, extraTypes: ExtraTypes): void;
+export declare function generateDefaultRpc(dest?: string, extraTypes?: ExtraTypes): void;

package/build/generate/runtime.d.ts

@@ -0,0 +1,7 @@
+import type { Metadata } from '@pezkuwi/types/metadata/Metadata';
+import type { Definitions, Registry } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+import { type ExtraTypes } from './types.js';
+/** @internal */
+export declare function generateCallTypes(registry: Registry, meta: Metadata, dest: string, extraTypes: ExtraTypes, isStrict: boolean, customLookupDefinitions?: Definitions): void;
+export declare function generateDefaultRuntime(dest: string, data: HexString, extraTypes?: ExtraTypes, isStrict?: boolean, customLookupDefinitions?: Definitions): void;

package/build/generate/tsDef.d.ts

@@ -0,0 +1,16 @@
+import type { Registry } from '@pezkuwi/types/types';
+import type { TypeDef } from '@pezkuwi/types-create/types';
+import type { ModuleTypes } from '../util/imports.js';
+import type { TypeImports } from '../util/index.js';
+import { TypeDefInfo } from '@pezkuwi/types-create';
+/** @internal */
+export declare function createGetter(definitions: Record<string, ModuleTypes>, name: string, type: string, imports: TypeImports): string;
+export declare const typeEncoders: Record<TypeDefInfo, (registry: Registry, definitions: Record<string, ModuleTypes>, def: TypeDef, imports: TypeImports) => string>;
+/** @internal */
+export declare function generateTsDefFor(registry: Registry, importDefinitions: Record<string, Record<string, ModuleTypes>>, defName: string, { types }: {
+    types: Record<string, any>;
+}, outputDir: string): void;
+/** @internal */
+export declare function generateTsDef(importDefinitions: Record<string, Record<string, ModuleTypes>>, outputDir: string, generatingPackage: string): void;
+/** @internal */
+export declare function generateDefaultTsDef(): void;

package/build/generate/tx.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 generateDefaultTx(dest: string, data: HexString, extraTypes?: ExtraTypes, isStrict?: boolean, customLookupDefinitions?: Definitions): void;

package/build/generate/types.d.ts

@@ -0,0 +1,12 @@
+import type { Option, Text } from '@pezkuwi/types-codec';
+export type ExtraTypes = Record<string, Record<string, {
+    runtime?: Record<string, any>;
+    types: Record<string, any>;
+}>>;
+export declare function getDeprecationNotice<T extends {
+    isDeprecated: boolean;
+    asDeprecated: {
+        note: Text;
+        since: Option<Text>;
+    };
+}>(deprecationInfo: T, name: string, label?: string): string;

package/build/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/build/interfacesTs.d.ts

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

package/build/metadataMd.d.ts

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

package/build/packageDetect.d.ts

@@ -0,0 +1 @@
+export {};

package/build/packageInfo.d.ts

@@ -0,0 +1,6 @@
+export declare const packageInfo: {
+    name: string;
+    path: string;
+    type: string;
+    version: string;
+};

package/build/scripts/polkadot-types-chain-info.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/extractChain';
+
+main();

package/build/scripts/polkadot-types-from-chain.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/fromChain';
+
+main();

package/build/scripts/polkadot-types-from-defs.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/fromDefs';
+
+main();

package/build/scripts/polkadot-types-internal-interfaces.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/interfacesTs';
+
+main();

package/build/scripts/polkadot-types-internal-metadata.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/metadataMd';
+
+main();

package/build/util/assert.d.ts

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

package/build/util/derived.d.ts

@@ -0,0 +1,4 @@
+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

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

package/build/util/file.d.ts

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

package/build/util/formatting.d.ts

@@ -0,0 +1,11 @@
+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, name: string, 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/imports.d.ts

@@ -0,0 +1,23 @@
+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 {};

package/build/util/index.d.ts

@@ -0,0 +1,15 @@
+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;

package/build/util/initMeta.d.ts

@@ -0,0 +1,12 @@
+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/register.d.ts

@@ -0,0 +1,4 @@
+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/wsMeta.d.ts

@@ -0,0 +1,4 @@
+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/package.json

@@ -0,0 +1,52 @@
+{
+  "author": "Jaco Greeff <jacogr@gmail.com>",
+  "bugs": "https://github.com/pezkuwichain/pezkuwi-api/issues",
+  "description": "Type generation scripts",
+  "engines": {
+    "node": ">=18"
+  },
+  "homepage": "https://github.com/pezkuwichain/pezkuwi-api/tree/master/packages/typegen#readme",
+  "license": "Apache-2.0",
+  "name": "@pezkuwi/typegen",
+  "repository": {
+    "directory": "packages/typegen",
+    "type": "git",
+    "url": "https://github.com/pezkuwichain/pezkuwi-api.git"
+  },
+  "sideEffects": [
+    "./packageDetect.js",
+    "./packageDetect.cjs"
+  ],
+  "type": "module",
+  "version": "16.5.5",
+  "main": "index.js",
+  "bin": {
+    "polkadot-types-chain-info": "./scripts/polkadot-types-chain-info.mjs",
+    "polkadot-types-from-chain": "./scripts/polkadot-types-from-chain.mjs",
+    "polkadot-types-from-defs": "./scripts/polkadot-types-from-defs.mjs",
+    "polkadot-types-internal-interfaces": "./scripts/polkadot-types-internal-interfaces.mjs",
+    "polkadot-types-internal-metadata": "./scripts/polkadot-types-internal-metadata.mjs"
+  },
+  "dependencies": {
+    "@pezkuwi/api": "16.5.5",
+    "@pezkuwi/api-augment": "16.5.5",
+    "@pezkuwi/api-derive": "16.5.5",
+    "@pezkuwi/rpc-augment": "16.5.5",
+    "@pezkuwi/rpc-provider": "16.5.5",
+    "@pezkuwi/types": "16.5.5",
+    "@pezkuwi/types-augment": "16.5.5",
+    "@pezkuwi/types-codec": "16.5.5",
+    "@pezkuwi/types-create": "16.5.5",
+    "@pezkuwi/types-support": "16.5.5",
+    "@pezkuwi/util": "14.0.5",
+    "@pezkuwi/util-crypto": "14.0.5",
+    "@pezkuwi/x-ws": "14.0.5",
+    "comment-parser": "^1.4.1",
+    "handlebars": "^4.7.8",
+    "tslib": "^2.8.1",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@types/yargs": "^17.0.33"
+  }
+}

package/scripts/polkadot-types-chain-info.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/extractChain';
+
+main();

package/scripts/polkadot-types-from-chain.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/fromChain';
+
+main();

package/scripts/polkadot-types-from-defs.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/fromDefs';
+
+main();

package/scripts/polkadot-types-internal-interfaces.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/interfacesTs';
+
+main();

package/scripts/polkadot-types-internal-metadata.mjs

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import { main } from '@pezkuwi/typegen/metadataMd';
+
+main();

package/src/augment.ts

@@ -0,0 +1,5 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import '@pezkuwi/api-augment';
+import '@pezkuwi/rpc-augment';

package/src/bundle.ts

@@ -0,0 +1,5 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+export { packageInfo } from './packageInfo.js';
+export { formatType } from './util/formatting.js';

package/src/extractChain.ts

@@ -0,0 +1,54 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+// Connects to the local chain and outputs a re-usable calls-only chain definition in  the form
+// export default { chain: 'Development', genesisHash: '0x27b6d5e0f4fdce1c4d20b82406f193acacce0c19e0d2c0e7ca47725c2572a06a', ss58Format: 42, tokenDecimals: 0, tokenSymbol: 'UNIT'; metaCalls: 'bWV0...4AAA==' };
+
+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: string): Promise<void> {
+  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);
+}
+
+interface ArgV { ws: string }
+
+export function main (): void {
+  // 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://kusama-rpc.polkadot.io',
+        required: true,
+        type: 'string'
+      }
+    }).argv as ArgV;
+
+  run(ws)
+    .then((): void => {
+      process.exit(0);
+    })
+    .catch((error: Error) => {
+      console.error('FATAL:', error.message);
+      process.exit(-1);
+    });
+}

package/src/fromChain.ts

@@ -0,0 +1,123 @@
+// Copyright 2017-2025 @polkadot/typegen authors & contributors
+// SPDX-License-Identifier: Apache-2.0
+
+import type { Definitions, DefinitionsTypes } from '@pezkuwi/types/types';
+import type { HexString } from '@pezkuwi/util/types';
+
+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: HexString, pkg: string | undefined, output: string, isStrict?: boolean): Promise<void> {
+  console.log(`Generating from metadata, ${formatNumber((metaHex.length - 2) / 2)} bytes`);
+
+  const outputPath = assertDir(path.join(process.cwd(), output));
+  let extraTypes: Record<string, any> = {};
+  let customLookupDefinitions: Definitions = { rpc: {}, types: {} };
+
+  if (pkg) {
+    try {
+      const defCont = await import(
+        assertFile(path.join(outputPath, 'definitions.ts'))
+      ) as Record<string, any>;
+
+      extraTypes = {
+        [pkg]: defCont
+      };
+    } catch (error) {
+      console.error('ERROR: No custom definitions found:', (error as Error).message);
+    }
+  }
+
+  try {
+    const lookCont = await import(
+      assertFile(path.join(outputPath, 'lookup.ts'))
+    ) as { default: DefinitionsTypes };
+
+    customLookupDefinitions = {
+      rpc: {},
+      types: lookCont.default
+    };
+  } catch (error) {
+    console.error('ERROR: No lookup definitions found:', (error as 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'), (): string =>
+    [
+      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);
+}
+
+interface ArgV { endpoint: string; output: string; package?: string; strict?: boolean }
+
+async function mainPromise (): Promise<void> {
+  const { endpoint, output, package: pkg, strict: isStrict } = yargs(hideBin(process.argv)).strict().options({
+    endpoint: {
+      description: 'The endpoint to connect to (e.g. wss://kusama-rpc.polkadot.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 as ArgV;
+
+  let metaHex: HexString;
+
+  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')
+      ) as { result: HexString }
+    ).result;
+
+    if (!isHex(metaHex)) {
+      throw new Error('Invalid metadata file');
+    }
+  }
+
+  await generate(metaHex, pkg, output, isStrict);
+}
+
+export function main (): void {
+  mainPromise().catch((error) => {
+    console.error();
+    console.error(error);
+    console.error();
+    process.exit(1);
+  });
+}