@cosmwasm/ts-codegen 0.7.3 → 0.8.1

package/module/commands/create-boilerplate.js

@@ -0,0 +1,116 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import * as shell from 'shelljs';
+import { prompt } from '../utils/prompt';
+import dargs from 'dargs';
+
+const glob = require('glob').sync;
+
+const fs = require('fs');
+
+const path = require('path');
+
+const repo = 'git@github.com:pyramation/tmpl-cosmwasm-module.git';
+export default (async argv => {
+  if (!shell.which('git')) {
+    shell.echo('Sorry, this script requires git');
+    return shell.exit(1);
+  }
+
+  const {
+    name
+  } = await prompt([{
+    type: 'string',
+    name: 'name',
+    message: 'Enter your new module name'
+  }], argv);
+  shell.exec(`git clone ${repo} ${name}`);
+  shell.cd(name);
+  const questions = JSON.parse(fs.readFileSync(`.questions.json`));
+  const fullname = shell.exec('git config --global user.name', {
+    silent: true
+  }).trim();
+  const email = shell.exec('git config --global user.email', {
+    silent: true
+  }).trim(); // @__USERNAME__/__MODULENAME__
+  // __PACKAGE_IDENTIFIER__
+
+  const args = dargs(_objectSpread(_objectSpread({
+    _: []
+  }, argv), {}, {
+    __MODULENAME__: name,
+    __USERFULLNAME__: fullname,
+    __USEREMAIL__: email
+  }), {
+    allowCamelCase: true
+  });
+  const results = await prompt(questions, args);
+  let scopedResults;
+  const license = await prompt([{
+    name: '__LICENSE__',
+    message: 'Which license?',
+    choices: ['MIT', 'closed'],
+    type: 'list',
+    required: true
+  }], []);
+
+  if (results.__ACCESS__ === 'public') {
+    scopedResults = await prompt([{
+      type: 'confirm',
+      name: 'scoped',
+      message: 'use npm scopes?',
+      required: true
+    }], []);
+  }
+
+  const files = [].concat(glob(process.cwd() + '/**/.*')).concat(glob(process.cwd() + '/**/*'));
+
+  for (let i = 0; i < files.length; i++) {
+    const templateFile = files[i];
+    if (fs.lstatSync(templateFile).isDirectory()) continue;
+    let content = fs.readFileSync(templateFile).toString();
+
+    if (path.basename(templateFile) === 'LICENSE' && license.__LICENSE__ === 'closed') {
+      content = `Copyright (c) 2022 __USERFULLNAME__ <__USEREMAIL__> - All Rights Reserved
+Unauthorized copying via any medium is strictly prohibited
+Proprietary and confidential`;
+    }
+
+    Object.keys(results).forEach(key => {
+      if (/^__/.test(key)) {
+        content = content.replace(new RegExp(key, 'g'), results[key]);
+      }
+    });
+
+    if (results.__ACCESS__ === 'public') {
+      if (scopedResults.scoped) {
+        content = content.replace(/__PACKAGE_IDENTIFIER__/g, `@${results.__USERNAME__}/${results.__MODULENAME__}`);
+      } else {
+        content = content.replace(/__PACKAGE_IDENTIFIER__/g, `${results.__MODULENAME__}`);
+      }
+    } else {
+      content = content.replace(/__PACKAGE_IDENTIFIER__/g, `@${results.__USERNAME__}/${results.__MODULENAME__}`);
+    }
+
+    if (path.basename(templateFile) === 'README.md') {
+      content = `# ${results.__MODULENAME__}`;
+    }
+
+    fs.writeFileSync(templateFile, content);
+  }
+
+  shell.rm('-rf', '.git');
+  shell.rm('-rf', '.questions.json');
+  console.log(`
+
+       |||
+      (o o)
+  ooO--(_)--Ooo-
+
+  ✨ Great work!
+  `);
+});

package/module/commands/generate.js

@@ -1,6 +1,5 @@
 import { prompt } from '../utils/prompt';
-import tsClient from '../generators/ts-client';
-import { readSchemas } from '../utils';
+import codegen from '../index';
 export default (async argv => {
   const questions = [{
     _: true,
@@ -19,15 +18,90 @@ export default (async argv => {
     type: 'string',
     name: 'name',
     message: 'contract name?'
+  }, {
+    type: 'checkbox',
+    name: 'plugin',
+    message: 'which plugins?',
+    choices: ['client', 'recoil', 'react-query', 'message-composer']
   }];
-  const {
+
+  if (argv.typesOnly) {
+    argv.plugin = 'types';
+  }
+
+  let {
     schema,
     out,
-    name
+    name,
+    plugin
   } = await prompt(questions, argv);
-  const schemas = await readSchemas({
-    schemaDir: schema,
-    argv
+  if (!Array.isArray(plugin)) plugin = [plugin]; ///////// REACT QUERY
+
+  const questions2 = [];
+
+  if (plugin.includes('react-query')) {
+    [].push.apply(questions2, [{
+      type: 'confirm',
+      name: 'optionalClient',
+      message: 'optionalClient?',
+      default: false
+    }, {
+      type: 'list',
+      name: 'version',
+      message: 'which react-query version?',
+      default: 'v3',
+      choices: ['v3', 'v4']
+    }]);
+  }
+
+  ;
+  const {
+    optionalClient,
+    version
+  } = await prompt(questions2, argv);
+  const questions3 = [];
+
+  if (version === 'v4') {
+    [].push.apply(questions3, [// currently we only support v4 for useMutation
+    {
+      type: 'confirm',
+      name: 'mutations',
+      message: 'Generate useMutation hooks?',
+      default: false
+    }]);
+  }
+
+  ;
+  const {
+    mutations
+  } = await prompt(questions3, argv); ///////// END REACT QUERY
+
+  const options = {
+    types: {
+      enabled: true
+    },
+    client: {
+      enabled: plugin.includes('client') || plugin.includes('recoil') || plugin.includes('react-query')
+    },
+    reactQuery: {
+      enabled: plugin.includes('react-query'),
+      optionalClient,
+      version,
+      mutations
+    },
+    recoil: {
+      enabled: plugin.includes('recoil')
+    },
+    messageComposer: {
+      enabled: plugin.includes('message-composer')
+    }
+  };
+  await codegen({
+    contracts: [{
+      name,
+      dir: schema
+    }],
+    outPath: out,
+    options
   });
-  await tsClient(name, schemas, out);
 });

package/module/generators/{ts-client.js → client.js}

@@ -6,13 +6,16 @@ import * as w from 'wasm-ast-types';
 import * as t from '@babel/types';
 import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
-import { clean } from "../utils/clean";
 import { getMessageProperties } from "wasm-ast-types";
 import { findAndParseTypes, findExecuteMsg, findQueryMsg, getDefinitionSchema } from '../utils';
-import { cosmjsAminoImportStatements } from '../utils/imports';
 import { RenderContext } from "wasm-ast-types";
-export default (async (name, schemas, outPath) => {
-  const Contract = pascal(`${name}Contract`) + '.ts';
+export default (async (name, schemas, outPath, tsClientOptions) => {
+  const context = new RenderContext(getDefinitionSchema(schemas), {
+    tsClient: tsClientOptions ?? {}
+  });
+  const options = context.options.tsClient;
+  const localname = pascal(name) + '.client.ts';
+  const TypesFile = pascal(name) + '.types';
   const QueryMsg = findQueryMsg(schemas);
   const ExecuteMsg = findExecuteMsg(schemas);
   const typeHash = await findAndParseTypes(schemas);
@@ -21,15 +24,7 @@ export default (async (name, schemas, outPath) => {
   let QueryClient = null;
   let ReadOnlyInstance = null;
   const body = [];
-  body.push(w.importStmt(['CosmWasmClient', 'ExecuteResult', 'SigningCosmWasmClient'], '@cosmjs/cosmwasm-stargate'));
-  body.push(cosmjsAminoImportStatements(typeHash)); // TYPES
-
-  Object.values(typeHash).forEach(type => {
-    body.push(clean(type));
-  }); // alias the ExecuteMsg
-
-  ExecuteMsg && body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
-  const context = new RenderContext(getDefinitionSchema(schemas)); // query messages
+  body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`)); // query messages
 
   if (QueryMsg) {
     QueryClient = pascal(`${name}QueryClient`);
@@ -50,7 +45,18 @@ export default (async (name, schemas, outPath) => {
     }
   }
 
-  const code = header + generate(t.program(body)).code;
+  if (typeHash.hasOwnProperty('Coin')) {
+    delete context.utils.Coin;
+  }
+
+  const imports = context.getImports();
+  const code = header + generate(t.program([...imports, ...body])).code;
   mkdirp(outPath);
-  writeFileSync(join(outPath, Contract), code);
+  writeFileSync(join(outPath, localname), code);
+  return [{
+    type: 'client',
+    contract: name,
+    localname,
+    filename: join(outPath, localname)
+  }];
 });

package/module/generators/{from-partial.js → message-composer.js}

@@ -9,22 +9,17 @@ import generate from "@babel/generator";
 import { getMessageProperties } from "wasm-ast-types";
 import { findAndParseTypes, findExecuteMsg, getDefinitionSchema } from "../utils";
 import { RenderContext } from "wasm-ast-types";
-export default (async (name, schemas, outPath) => {
-  const FromPartialFile = pascal(`${name}Contract`) + '.from-partial.ts';
-  const Contract = pascal(`${name}Contract`) + '.ts';
+export default (async (name, schemas, outPath, messageComposerOptions) => {
+  const context = new RenderContext(getDefinitionSchema(schemas), {
+    messageComposer: messageComposerOptions ?? {}
+  });
+  const options = context.options.messageComposer;
+  const localname = pascal(name) + '.message-composer.ts';
+  const TypesFile = pascal(name) + '.types';
   const ExecuteMsg = findExecuteMsg(schemas);
   const typeHash = await findAndParseTypes(schemas);
   const body = [];
-  body.push(w.importStmt(['MsgExecuteContractEncodeObject'], 'cosmwasm'));
-  body.push(w.importStmt(['MsgExecuteContract'], 'cosmjs-types/cosmwasm/wasm/v1/tx'));
-  body.push(w.importStmt(['toUtf8'], '@cosmjs/encoding'));
-
-  if (!typeHash.hasOwnProperty('Coin')) {
-    body.push(w.importStmt(['Coin'], '@cosmjs/amino'));
-  }
-
-  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, '')));
-  const context = new RenderContext(getDefinitionSchema(schemas)); // execute messages
+  body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`)); // execute messages
 
   if (ExecuteMsg) {
     const children = getMessageProperties(ExecuteMsg);
@@ -32,12 +27,23 @@ export default (async (name, schemas, outPath) => {
     if (children.length > 0) {
       const TheClass = pascal(`${name}MessageComposer`);
       const Interface = pascal(`${name}Message`);
-      body.push(w.createFromPartialInterface(context, Interface, ExecuteMsg));
-      body.push(w.createFromPartialClass(context, TheClass, Interface, ExecuteMsg));
+      body.push(w.createMessageComposerInterface(context, Interface, ExecuteMsg));
+      body.push(w.createMessageComposerClass(context, TheClass, Interface, ExecuteMsg));
     }
   }
 
-  const code = header + generate(t.program(body)).code;
+  if (typeHash.hasOwnProperty('Coin')) {
+    delete context.utils.Coin;
+  }
+
+  const imports = context.getImports();
+  const code = header + generate(t.program([...imports, ...body])).code;
   mkdirp(outPath);
-  writeFileSync(join(outPath, FromPartialFile), code);
+  writeFileSync(join(outPath, localname), code);
+  return [{
+    type: 'message-composer',
+    contract: name,
+    localname,
+    filename: join(outPath, localname)
+  }];
 });

package/module/generators/react-query.js

@@ -9,39 +9,33 @@ import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
 import { findAndParseTypes, findExecuteMsg, findQueryMsg, getDefinitionSchema } from '../utils';
 import { getMessageProperties } from "wasm-ast-types";
-import { cosmjsAminoImportStatements } from '../utils/imports';
 export default (async (contractName, schemas, outPath, reactQueryOptions) => {
   const context = new RenderContext(getDefinitionSchema(schemas), {
     reactQuery: reactQueryOptions ?? {}
   });
   const options = context.options.reactQuery;
-  const ReactQueryFile = pascal(`${contractName}Contract`) + '.react-query.ts';
-  const Contract = pascal(`${contractName}Contract`);
+  const localname = pascal(`${contractName}`) + '.react-query.ts';
+  const ContractFile = pascal(`${contractName}`) + '.client';
+  const TypesFile = pascal(`${contractName}`) + '.types';
   const QueryMsg = findQueryMsg(schemas);
   const ExecuteMsg = findExecuteMsg(schemas);
   const typeHash = await findAndParseTypes(schemas);
   const ExecuteClient = pascal(`${contractName}Client`);
   const QueryClient = pascal(`${contractName}QueryClient`);
   const body = [];
-  const reactQueryImports = ['useQuery', 'UseQueryOptions'];
   const clientImports = [];
   QueryMsg && clientImports.push(QueryClient); // check that there are commands within the exec msg
 
-  const shouldGenerateMutationHooks = ExecuteMsg && options?.v4 && options?.mutations && getMessageProperties(ExecuteMsg).length > 0;
+  const shouldGenerateMutationHooks = ExecuteMsg && options?.version === 'v4' && options?.mutations && getMessageProperties(ExecuteMsg).length > 0;
 
   if (shouldGenerateMutationHooks) {
-    body.push(w.importStmt(['ExecuteResult'], '@cosmjs/cosmwasm-stargate'));
-    body.push(cosmjsAminoImportStatements(typeHash));
-    reactQueryImports.push('useMutation', 'UseMutationOptions');
     clientImports.push(ExecuteClient);
-  } // react-query imports
+  } // general contract imports
 
 
-  body.push(w.importStmt(reactQueryImports, options?.v4 ? '@tanstack/react-query' : 'react-query')); // general contract imports
+  body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`)); // client imports
 
-  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`)); // client imports
-
-  body.push(w.importStmt(clientImports, `./${Contract}`)); // query messages
+  body.push(w.importStmt(clientImports, `./${ContractFile}`)); // query messages
 
   if (QueryMsg) {
     [].push.apply(body, w.createReactQueryHooks({
@@ -61,7 +55,18 @@ export default (async (contractName, schemas, outPath, reactQueryOptions) => {
     }));
   }
 
-  const code = header + generate(t.program(body)).code;
+  if (typeHash.hasOwnProperty('Coin')) {
+    delete context.utils.Coin;
+  }
+
+  const imports = context.getImports();
+  const code = header + generate(t.program([...imports, ...body])).code;
   mkdirp(outPath);
-  writeFileSync(join(outPath, ReactQueryFile), code);
+  writeFileSync(join(outPath, localname), code);
+  return [{
+    type: 'react-query',
+    contract: contractName,
+    localname,
+    filename: join(outPath, localname)
+  }];
 });

package/module/generators/recoil.js

@@ -8,29 +8,43 @@ import { writeFileSync } from 'fs';
 import generate from "@babel/generator";
 import { findAndParseTypes, findQueryMsg, getDefinitionSchema } from "../utils";
 import { RenderContext } from "wasm-ast-types";
-export default (async (name, schemas, outPath) => {
-  const RecoilFile = pascal(`${name}Contract`) + '.recoil.ts';
-  const Contract = pascal(`${name}Contract`) + '.ts';
+export default (async (name, schemas, outPath, recoilOptions) => {
+  const context = new RenderContext(getDefinitionSchema(schemas), {
+    recoil: recoilOptions ?? {}
+  });
+  const options = context.options.recoil;
+  const localname = pascal(name) + '.recoil.ts';
+  const ContractFile = pascal(name) + '.client';
+  const TypesFile = pascal(name) + '.types';
   const QueryMsg = findQueryMsg(schemas);
   const typeHash = await findAndParseTypes(schemas);
   let QueryClient = null;
   let ReadOnlyInstance = null;
   const body = [];
-  body.push(w.importStmt(['selectorFamily'], 'recoil'));
   body.push(w.importStmt(['cosmWasmClient'], './chain'));
-  body.push(w.importStmt(Object.keys(typeHash), `./${Contract}`.replace(/\.ts$/, '')));
-  const context = new RenderContext(getDefinitionSchema(schemas)); // query messages
+  body.push(w.importStmt(Object.keys(typeHash), `./${TypesFile}`)); // query messages
 
   if (QueryMsg) {
     QueryClient = pascal(`${name}QueryClient`);
     ReadOnlyInstance = pascal(`${name}ReadOnlyInterface`);
-    body.push(w.importStmt([QueryClient], `./${Contract}`));
+    body.push(w.importStmt([QueryClient], `./${ContractFile}`));
     body.push(w.createRecoilQueryClientType());
     body.push(w.createRecoilQueryClient(context, name, QueryClient));
     [].push.apply(body, w.createRecoilSelectors(context, name, QueryClient, QueryMsg));
   }
 
-  const code = header + generate(t.program(body)).code;
+  if (typeHash.hasOwnProperty('Coin')) {
+    delete context.utils.Coin;
+  }
+
+  const imports = context.getImports();
+  const code = header + generate(t.program([...imports, ...body])).code;
   mkdirp(outPath);
-  writeFileSync(join(outPath, RecoilFile), code);
+  writeFileSync(join(outPath, localname), code);
+  return [{
+    type: 'recoil',
+    contract: name,
+    localname,
+    filename: join(outPath, localname)
+  }];
 });

package/module/generators/types.js

@@ -0,0 +1,40 @@
+import { pascal } from "case";
+import { header } from '../utils/header';
+import { join } from "path";
+import { sync as mkdirp } from "mkdirp";
+import * as t from '@babel/types';
+import { writeFileSync } from 'fs';
+import generate from "@babel/generator";
+import { clean } from "../utils/clean";
+import { findAndParseTypes, findExecuteMsg, getDefinitionSchema } from '../utils';
+import { RenderContext } from "wasm-ast-types";
+export default (async (name, schemas, outPath, tsTypesOptions) => {
+  const context = new RenderContext(getDefinitionSchema(schemas), {
+    tsClient: tsTypesOptions ?? {}
+  });
+  const options = context.options.types;
+  const localname = pascal(name) + '.types.ts';
+  const ExecuteMsg = findExecuteMsg(schemas);
+  const typeHash = await findAndParseTypes(schemas);
+  const body = []; // TYPES
+
+  Object.values(typeHash).forEach(type => {
+    body.push(clean(type));
+  }); // alias the ExecuteMsg
+
+  if (options.aliasExecuteMsg && ExecuteMsg) {
+    body.push(t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(`${name}ExecuteMsg`), null, t.tsTypeReference(t.identifier('ExecuteMsg')))));
+  }
+
+  const imports = context.getImports();
+  const code = header + generate(t.program([...imports, ...body])).code;
+  mkdirp(outPath);
+  const filename = join(outPath, localname);
+  writeFileSync(filename, code);
+  return [{
+    type: 'type',
+    contract: name,
+    localname,
+    filename
+  }];
+});

package/module/index.js

@@ -1,6 +1,13 @@
-export { default as tsClient } from './generators/ts-client';
-export { default as fromPartial } from './generators/from-partial';
-export { default as reactQuery } from './generators/react-query';
-export { default as recoil } from './generators/recoil';
+import { TSBuilder } from './builder';
+export { default as generateTypes } from './generators/types';
+export { default as generateClient } from './generators/client';
+export { default as generateMessageComposer } from './generators/message-composer';
+export { default as generateReactQuery } from './generators/react-query';
+export { default as generateRecoil } from './generators/recoil';
 export * from './utils';
-export * from './utils/imports';
+export * from './builder';
+export * from './bundler';
+export default (async input => {
+  const builder = new TSBuilder(input);
+  await builder.build();
+});

package/module/types.js

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

package/module/utils/schemas.js

@@ -9,16 +9,17 @@ import { readFileSync } from 'fs';
 import { cleanse } from './cleanse';
 import { compile } from 'json-schema-to-typescript';
 import { parser } from './parse';
+;
 export const readSchemas = async ({
   schemaDir,
-  argv,
+  schemaOptions,
   clean = true
 }) => {
   const fn = clean ? cleanse : str => str;
   const files = glob(schemaDir + '/**/*.json');
   const schemas = files.map(file => JSON.parse(readFileSync(file, 'utf-8')));
 
-  if (argv.packed) {
+  if (schemaOptions?.packed) {
     if (schemas.length !== 1) {
       throw new Error('packed option only supports one file');
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmwasm/ts-codegen",
-  "version": "0.7.3",
+  "version": "0.8.1",
   "description": "@cosmwasm/ts-codegen converts your CosmWasm smart contracts into dev-friendly TypeScript classes so you can focus on shipping code.",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/cosmwasm/ts-codegen",
@@ -82,6 +82,7 @@
     "@babel/types": "7.18.10",
     "case": "1.6.3",
     "dargs": "7.0.0",
+    "dotty": "0.1.2",
     "fuzzy": "0.1.3",
     "glob": "8.0.3",
     "inquirerer": "0.1.3",
@@ -89,8 +90,9 @@
     "long": "^5.2.0",
     "minimist": "1.2.6",
     "mkdirp": "1.0.4",
+    "parse-package-name": "1.0.0",
     "shelljs": "0.8.5",
-    "wasm-ast-types": "^0.6.1"
+    "wasm-ast-types": "^0.7.0"
   },
-  "gitHead": "6a9da6ddd47a5c9cebebf5fb05f5c1edea2868e2"
+  "gitHead": "a926a306b0faccb7f4c6d258d53fad9b689ecdfd"
 }

package/types/builder/builder.d.ts

@@ -0,0 +1,39 @@
+import { RenderOptions } from "wasm-ast-types";
+export interface TSBuilderInput {
+    contracts: Array<ContractFile | string>;
+    outPath: string;
+    options?: TSBuilderOptions;
+}
+export interface BundleOptions {
+    enabled?: boolean;
+    scope?: string;
+    bundleFile?: string;
+}
+export declare type TSBuilderOptions = {
+    bundle?: BundleOptions;
+} & RenderOptions;
+export interface BuilderFile {
+    type: 'type' | 'client' | 'recoil' | 'react-query' | 'message-composer';
+    contract: string;
+    localname: string;
+    filename: string;
+}
+export interface ContractFile {
+    name: string;
+    dir: string;
+}
+export declare class TSBuilder {
+    contracts: Array<ContractFile | string>;
+    outPath: string;
+    options?: TSBuilderOptions;
+    protected files: BuilderFile[];
+    constructor({ contracts, outPath, options }: TSBuilderInput);
+    getContracts(): ContractFile[];
+    renderTypes(contract: ContractFile): Promise<void>;
+    renderClient(contract: ContractFile): Promise<void>;
+    renderRecoil(contract: ContractFile): Promise<void>;
+    renderReactQuery(contract: ContractFile): Promise<void>;
+    renderMessageComposer(contract: ContractFile): Promise<void>;
+    build(): Promise<void>;
+    bundle(): Promise<void>;
+}

package/types/builder/index.d.ts

@@ -0,0 +1 @@
+export * from './builder';

package/types/bundler/bundler.d.ts

@@ -0,0 +1,4 @@
+import * as t from '@babel/types';
+export declare const recursiveModuleBundle: (obj: any) => any;
+export declare const importNamespace: (ident: string, path: string) => t.ImportDeclaration;
+export declare const createFileBundle: (pkg: any, filename: any, bundleFile: any, importPaths: any, bundleVariables: any) => void;

package/types/bundler/index.d.ts

@@ -0,0 +1 @@
+export * from './bundler';

package/types/commands/message-composer.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (argv: any) => Promise<void>;
+export default _default;

package/types/commands/types.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (argv: any) => Promise<void>;
+export default _default;

package/types/generators/client.d.ts

@@ -0,0 +1,3 @@
+import { BuilderFile } from "../builder";
+declare const _default: (name: string, schemas: any[], outPath: string, tsClientOptions?: TsClientOptions) => Promise<BuilderFile[]>;
+export default _default;

package/types/generators/message-composer.d.ts

@@ -0,0 +1,3 @@
+import { BuilderFile } from "../builder";
+declare const _default: (name: string, schemas: any[], outPath: string, messageComposerOptions?: MessageComposerOptions) => Promise<BuilderFile[]>;
+export default _default;

package/types/generators/react-query.d.ts

@@ -1,2 +1,3 @@
-declare const _default: (contractName: string, schemas: any[], outPath: string, reactQueryOptions?: ReactQueryOptions) => Promise<void>;
+import { BuilderFile } from "../builder";
+declare const _default: (contractName: string, schemas: any[], outPath: string, reactQueryOptions?: ReactQueryOptions) => Promise<BuilderFile[]>;
 export default _default;

package/types/generators/recoil.d.ts

@@ -1,2 +1,3 @@
-declare const _default: (name: string, schemas: any[], outPath: string) => Promise<void>;
+import { BuilderFile } from "../builder";
+declare const _default: (name: string, schemas: any[], outPath: string, recoilOptions?: RecoilOptions) => Promise<BuilderFile[]>;
 export default _default;

package/types/generators/types.d.ts

@@ -0,0 +1,3 @@
+import { BuilderFile } from "../builder";
+declare const _default: (name: string, schemas: any[], outPath: string, tsTypesOptions?: TSTypesOptions) => Promise<BuilderFile[]>;
+export default _default;