wasm-ast-types 0.8.1 → 0.10.0

package/module/context/context.js

@@ -1,7 +1,13 @@
 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 { convertUtilsToImportList, getImportStatements } from "./imports";
 import deepmerge from "deepmerge"; /// Plugin Types
 
+;
 export const defaultOptions = {
   types: {
     enabled: true,
@@ -21,16 +27,31 @@ export const defaultOptions = {
     optionalClient: false,
     version: 'v3',
     mutations: false,
-    camelize: true
+    camelize: true,
+    queryKeys: false
   }
 };
+export const getDefinitionSchema = schemas => {
+  const aggregateSchema = {
+    definitions: {//
+    }
+  };
+  schemas.forEach(schema => {
+    schema.definitions = schema.definitions || {};
+    aggregateSchema.definitions = _objectSpread(_objectSpread({}, aggregateSchema.definitions), schema.definitions);
+  });
+  return aggregateSchema;
+};
 export class RenderContext {
-  constructor(schema, options) {
-    _defineProperty(this, "schema", void 0);
+  constructor(contract, options) {
+    _defineProperty(this, "contract", void 0);
 
     _defineProperty(this, "utils", []);
 
-    this.schema = schema;
+    _defineProperty(this, "schema", void 0);
+
+    this.contract = contract;
+    this.schema = getDefinitionSchema(contract.schemas);
     this.options = deepmerge(defaultOptions, options ?? {});
   }
 

package/module/message-composer/message-composer.spec.js

@@ -1,12 +1,11 @@
 import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
 import { createMessageComposerClass, createMessageComposerInterface } from './message-composer';
-import { RenderContext } from '../context';
-import { expectCode } from '../../test-utils';
+import { expectCode, makeContext } from '../../test-utils';
 it('execute classes', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createMessageComposerClass(ctx, 'SG721MessageComposer', 'SG721Message', execute_msg));
 });
 it('createMessageComposerInterface', () => {
-  const ctx = new RenderContext(execute_msg);
+  const ctx = makeContext(execute_msg);
   expectCode(createMessageComposerInterface(ctx, 'SG721Message', execute_msg));
 });

package/module/react-query/react-query.js

@@ -2,7 +2,7 @@ import * as t from '@babel/types';
 import { camel, pascal } from 'case';
 import { callExpression, getMessageProperties, identifier, tsObjectPattern, tsPropertySignature } from '../utils';
 import { omitTypeReference, optionalConditionalExpression, propertySignature, shorthandProperty } from '../utils/babel';
-import { getParamsTypeAnnotation, getPropertyType } from '../utils/types';
+import { getParamsTypeAnnotation, getPropertyType, getResponseType } from '../utils/types';
 import { FIXED_EXECUTE_PARAMS } from '../client';
 export const createReactQueryHooks = ({
   context,
@@ -12,17 +12,36 @@ export const createReactQueryHooks = ({
 }) => {
   const options = context.options.reactQuery;
   const genericQueryInterfaceName = `${pascal(contractName)}ReactQuery`;
-  const body = [createReactQueryHookGenericInterface({
+  const underscoreNames = getMessageProperties(queryMsg).map(schema => Object.keys(schema.properties)[0]);
+  const body = [];
+  const queryKeysName = `${camel(contractName)}QueryKeys`;
+
+  if (options.queryKeys) {
+    body.push(createReactQueryKeys({
+      context,
+      queryKeysName,
+      camelContractName: camel(contractName),
+      underscoreNames
+    }));
+  }
+
+  body.push(createReactQueryHookGenericInterface({
     context,
     QueryClient,
     genericQueryInterfaceName
-  })];
+  }));
   body.push(...getMessageProperties(queryMsg).reduce((m, schema) => {
-    const underscoreName = Object.keys(schema.properties)[0];
-    const methodName = camel(underscoreName);
-    const hookParamsTypeName = `${pascal(contractName)}${pascal(methodName)}Query`;
-    const hookName = `use${hookParamsTypeName}`;
-    const responseType = pascal(`${methodName}Response`);
+    // list_voters
+    const underscoreName = Object.keys(schema.properties)[0]; // listVoters
+
+    const methodName = camel(underscoreName); // Cw3FlexMultisigListVotersQuery
+
+    const hookParamsTypeName = `${pascal(contractName)}${pascal(methodName)}Query`; // useCw3FlexMultisigListVotersQuery
+
+    const hookName = `use${hookParamsTypeName}`; // listVotersResponse
+
+    const responseType = getResponseType(context, underscoreName); // cw3FlexMultisigListVoters
+
     const getterKey = camel(`${contractName}${pascal(methodName)}`);
     const jsonschema = schema.properties[underscoreName];
     return [createReactQueryHookInterface({
@@ -37,6 +56,7 @@ export const createReactQueryHooks = ({
       methodName,
       hookName,
       hookParamsTypeName,
+      queryKeysName,
       responseType,
       hookKeyName: getterKey,
       jsonschema
@@ -50,6 +70,7 @@ export const createReactQueryHook = ({
   hookParamsTypeName,
   responseType,
   hookKeyName,
+  queryKeysName,
   methodName,
   jsonschema
 }) => {
@@ -71,10 +92,20 @@ export const createReactQueryHook = ({
     props = ['client', 'args', 'options'];
   }
 
-  return t.exportNamedDeclaration(t.functionDeclaration(t.identifier(hookName), [tsObjectPattern([...props.map(prop => {
+  const selectResponseGenericTypeName = 'TData';
+  const queryFunctionDeclaration = t.functionDeclaration(t.identifier(hookName), [tsObjectPattern([...props.map(prop => {
     return t.objectProperty(t.identifier(prop), t.identifier(prop), false, true);
-  })], t.tsTypeAnnotation(t.tsTypeReference(t.identifier(hookParamsTypeName))))], t.blockStatement([t.returnStatement(callExpression(t.identifier('useQuery'), [t.arrayExpression(generateUseQueryQueryKey(hookKeyName, props, options.optionalClient)), t.arrowFunctionExpression([], optionalConditionalExpression(t.identifier('client'), t.callExpression(t.memberExpression(t.identifier('client'), t.identifier(methodName)), args), t.callExpression(t.memberExpression(t.identifier('Promise'), t.identifier('reject')), [t.newExpression(t.identifier('Error'), [t.stringLiteral('Invalid client')])]), options.optionalClient), false), options.optionalClient ? t.objectExpression([t.spreadElement(t.identifier('options')), t.objectProperty(t.identifier('enabled'), t.logicalExpression('&&', t.unaryExpression('!', t.unaryExpression('!', t.identifier('client'))), t.conditionalExpression( // explicitly check for undefined
-  t.binaryExpression('!=', t.optionalMemberExpression(t.identifier('options'), t.identifier('enabled'), false, true), t.identifier('undefined')), t.memberExpression(t.identifier('options'), t.identifier('enabled')), t.booleanLiteral(true))))]) : t.identifier('options')], t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(responseType)), t.tsTypeReference(t.identifier('Error')), t.tsTypeReference(t.identifier(responseType)), t.tsArrayType(t.tsParenthesizedType(t.tsUnionType([t.tsStringKeyword(), t.tsUndefinedKeyword()])))])))])));
+  })], t.tsTypeAnnotation(t.tsTypeReference(t.identifier(hookParamsTypeName), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(selectResponseGenericTypeName))]))))], t.blockStatement([t.returnStatement(callExpression(t.identifier('useQuery'), [generateUseQueryQueryKey({
+    hookKeyName,
+    queryKeysName,
+    methodName,
+    props,
+    options
+  }), t.arrowFunctionExpression([], optionalConditionalExpression(t.identifier('client'), t.callExpression(t.memberExpression(t.identifier('client'), t.identifier(methodName)), args), t.callExpression(t.memberExpression(t.identifier('Promise'), t.identifier('reject')), [t.newExpression(t.identifier('Error'), [t.stringLiteral('Invalid client')])]), options.optionalClient), false), options.optionalClient ? t.objectExpression([t.spreadElement(t.identifier('options')), t.objectProperty(t.identifier('enabled'), t.logicalExpression('&&', t.unaryExpression('!', t.unaryExpression('!', t.identifier('client'))), t.conditionalExpression( // explicitly check for undefined
+  t.binaryExpression('!=', t.optionalMemberExpression(t.identifier('options'), t.identifier('enabled'), false, true), t.identifier('undefined')), t.memberExpression(t.identifier('options'), t.identifier('enabled')), t.booleanLiteral(true))))]) : t.identifier('options')], t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(responseType)), t.tsTypeReference(t.identifier('Error')), t.tsTypeReference(t.identifier(selectResponseGenericTypeName))])))])); // Add the TData type parameters
+
+  queryFunctionDeclaration.typeParameters = t.tsTypeParameterDeclaration([t.tsTypeParameter(undefined, t.tSTypeReference(t.identifier(responseType)), selectResponseGenericTypeName)]);
+  return t.exportNamedDeclaration(queryFunctionDeclaration);
 };
 
 /**
@@ -196,17 +227,44 @@ export const createReactQueryMutationHook = ({
   ), t.identifier('options')], useMutationTypeParameter))])));
 };
 
+function createReactQueryKeys({
+  context,
+  queryKeysName,
+  camelContractName,
+  underscoreNames
+}) {
+  const options = context.options.reactQuery;
+  const contractAddressTypeAnnotation = t.tsTypeAnnotation(options.optionalClient ? t.tsUnionType([t.tsStringKeyword(), t.tsUndefinedKeyword()]) : t.tSStringKeyword());
+  return t.exportNamedDeclaration(t.variableDeclaration('const', [t.variableDeclarator(t.identifier(queryKeysName), t.objectExpression([// 1: contract
+  t.objectProperty(t.identifier('contract'), t.tSAsExpression(t.arrayExpression([t.objectExpression([t.objectProperty(t.identifier('contract'), t.stringLiteral(camelContractName))])]), t.tSTypeReference(t.identifier('const')))), // 2: address
+  t.objectProperty(t.identifier('address'), t.arrowFunctionExpression([identifier('contractAddress', contractAddressTypeAnnotation)], t.tSAsExpression(t.arrayExpression([t.objectExpression([// 1
+  t.spreadElement(t.memberExpression(t.memberExpression(t.identifier(queryKeysName), t.identifier('contract')), t.numericLiteral(0), true // computed
+  )), t.objectProperty(t.identifier('address'), t.identifier('contractAddress'))])]), t.tSTypeReference(t.identifier('const'))))), // 3: methods
+  ...underscoreNames.map(underscoreMethodName => t.objectProperty( // key id is the camel method name
+  t.identifier(camel(underscoreMethodName)), t.arrowFunctionExpression([identifier('contractAddress', contractAddressTypeAnnotation), identifier('args', // Record<string, unknown>
+  t.tSTypeAnnotation(t.tsTypeReference(t.identifier('Record'), t.tsTypeParameterInstantiation([t.tsStringKeyword(), t.tsUnknownKeyword()]))), true // optional
+  )], t.tSAsExpression(t.arrayExpression([t.objectExpression([//...cw3FlexMultisigQueryKeys.address(contractAddress)[0]
+  t.spreadElement(t.memberExpression(t.callExpression(t.memberExpression(t.identifier(queryKeysName), t.identifier('address')), [t.identifier('contractAddress')]), t.numericLiteral(0), true // computed
+  )), // method: list_voters
+  t.objectProperty(t.identifier('method'), t.stringLiteral(underscoreMethodName)), // args
+  shorthandProperty('args')])]), t.tSTypeReference(t.identifier('const'))))))]))]));
+}
+
 function createReactQueryHookGenericInterface({
   context,
   QueryClient,
   genericQueryInterfaceName
 }) {
   const options = context.options.reactQuery;
-  const genericTypeName = 'TResponse';
-  context.addUtil('UseQueryOptions');
-  const typedUseQueryOptions = t.tsTypeReference(t.identifier('UseQueryOptions'), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(genericTypeName)), t.tsTypeReference(t.identifier('Error')), t.tsTypeReference(t.identifier(genericTypeName)), t.tsArrayType(t.tsParenthesizedType(t.tsUnionType([t.tsStringKeyword(), t.tsUndefinedKeyword()])))]));
+  const genericResponseTypeName = 'TResponse';
+  const genericSelectResponseTypeName = 'TData';
+  context.addUtil('UseQueryOptions'); // UseQueryOptions<TResponse, Error, TData>,
+
+  const typedUseQueryOptions = t.tsTypeReference(t.identifier('UseQueryOptions'), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(genericResponseTypeName)), t.tsTypeReference(t.identifier('Error')), t.tsTypeReference(t.identifier(genericSelectResponseTypeName))]));
   const body = [tsPropertySignature(t.identifier('client'), t.tsTypeAnnotation(options.optionalClient ? t.tsUnionType([t.tsTypeReference(t.identifier(QueryClient)), t.tsUndefinedKeyword()]) : t.tsTypeReference(t.identifier(QueryClient))), false), tsPropertySignature(t.identifier('options'), t.tsTypeAnnotation(options.version === 'v4' ? t.tSIntersectionType([omitTypeReference(typedUseQueryOptions, "'queryKey' | 'queryFn' | 'initialData'"), t.tSTypeLiteral([t.tsPropertySignature(t.identifier('initialData?'), t.tsTypeAnnotation(t.tsUndefinedKeyword()))])]) : typedUseQueryOptions), true)];
-  return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(genericQueryInterfaceName), t.tsTypeParameterDeclaration([t.tsTypeParameter(undefined, undefined, genericTypeName)]), [], t.tSInterfaceBody(body)));
+  return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(genericQueryInterfaceName), t.tsTypeParameterDeclaration([// 1: TResponse
+  t.tsTypeParameter(undefined, undefined, genericResponseTypeName), // 2: TData
+  t.tsTypeParameter(undefined, t.tSTypeReference(t.identifier(genericResponseTypeName)), genericSelectResponseTypeName)]), [], t.tSInterfaceBody(body)));
 }
 
 export const createReactQueryHookInterface = ({
@@ -227,7 +285,9 @@ export const createReactQueryHookInterface = ({
     t.tsTypeLiteral(props))));
   }
 
-  return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(hookParamsTypeName), null, [t.tSExpressionWithTypeArguments(t.identifier(queryInterfaceName), t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(responseType))]))], t.tsInterfaceBody(body)));
+  return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(hookParamsTypeName), t.tsTypeParameterDeclaration([t.tSTypeParameter(undefined, undefined, 'TData')]), [t.tSExpressionWithTypeArguments(t.identifier(queryInterfaceName), t.tsTypeParameterInstantiation([// 1: response
+  t.tsTypeReference(t.identifier(responseType)), // 2: select generic
+  t.tSTypeReference(t.identifier('TData'))]))], t.tsInterfaceBody(body)));
 };
 
 const getProps = (context, jsonschema) => {
@@ -242,12 +302,31 @@ const getProps = (context, jsonschema) => {
   });
 };
 
-const generateUseQueryQueryKey = (hookKeyName, props, optionalClient) => {
-  const queryKey = [t.stringLiteral(hookKeyName), t.optionalMemberExpression(t.identifier('client'), t.identifier('contractAddress'), false, optionalClient)];
+const generateUseQueryQueryKey = ({
+  hookKeyName,
+  queryKeysName,
+  methodName,
+  props,
+  options
+}) => {
+  const {
+    optionalClient,
+    queryKeys
+  } = options;
+  const hasArgs = props.includes('args');
+  const contractAddressExpression = t.optionalMemberExpression(t.identifier('client'), t.identifier('contractAddress'), false, optionalClient);
+
+  if (queryKeys) {
+    const callArgs = [contractAddressExpression];
+    if (hasArgs) callArgs.push(t.identifier('args'));
+    return t.callExpression(t.memberExpression(t.identifier(queryKeysName), t.identifier(camel(methodName))), callArgs);
+  }
+
+  const queryKey = [t.stringLiteral(hookKeyName), contractAddressExpression];
 
-  if (props.includes('args')) {
+  if (hasArgs) {
     queryKey.push(t.callExpression(t.memberExpression(t.identifier('JSON'), t.identifier('stringify')), [t.identifier('args')]));
   }
 
-  return queryKey;
+  return t.arrayExpression(queryKey);
 };

package/module/react-query/react-query.spec.js

@@ -1,11 +1,10 @@
 import * as t from '@babel/types';
 import query_msg from '../../../../__fixtures__/basic/query_msg.json';
 import execute_msg from '../../../../__fixtures__/basic/execute_msg_for__empty.json';
-import { RenderContext } from '../context';
 import { createReactQueryHooks, createReactQueryMutationHooks } from './react-query';
-import { expectCode } from '../../test-utils';
-const execCtx = new RenderContext(execute_msg);
-const queryCtx = new RenderContext(query_msg);
+import { expectCode, makeContext } from '../../test-utils';
+const execCtx = makeContext(execute_msg);
+const queryCtx = makeContext(query_msg);
 it('createReactQueryHooks', () => {
   expectCode(t.program(createReactQueryHooks({
     context: queryCtx,
@@ -14,7 +13,7 @@ it('createReactQueryHooks', () => {
     QueryClient: 'Sg721QueryClient'
   })));
   expectCode(t.program(createReactQueryHooks({
-    context: new RenderContext(query_msg, {
+    context: makeContext(query_msg, {
       reactQuery: {
         optionalClient: true
       }
@@ -24,7 +23,7 @@ it('createReactQueryHooks', () => {
     QueryClient: 'Sg721QueryClient'
   })));
   expectCode(t.program(createReactQueryHooks({
-    context: new RenderContext(query_msg, {
+    context: makeContext(query_msg, {
       reactQuery: {
         version: 'v4'
       }
@@ -34,7 +33,7 @@ it('createReactQueryHooks', () => {
     QueryClient: 'Sg721QueryClient'
   })));
   expectCode(t.program(createReactQueryHooks({
-    context: new RenderContext(query_msg, {
+    context: makeContext(query_msg, {
       reactQuery: {
         optionalClient: true,
         version: 'v4'

package/module/recoil/recoil.js

@@ -1,10 +1,9 @@
 import * as t from '@babel/types';
 import { camel, pascal } from 'case';
-import { callExpression, getMessageProperties } from '../utils';
-export const createRecoilSelector = (context, keyPrefix, QueryClient, methodName) => {
+import { callExpression, getMessageProperties, getResponseType } from '../utils';
+export const createRecoilSelector = (context, keyPrefix, QueryClient, methodName, responseType) => {
   context.addUtil('selectorFamily');
   const selectorName = camel(`${methodName}Selector`);
-  const responseType = pascal(`${methodName}Response`);
   const getterKey = camel(`${keyPrefix}${pascal(methodName)}`);
   return t.exportNamedDeclaration(t.variableDeclaration('const', [t.variableDeclarator(t.identifier(selectorName), callExpression(t.identifier('selectorFamily'), [t.objectExpression([t.objectProperty(t.identifier('key'), t.stringLiteral(getterKey)), t.objectProperty(t.identifier('get'), t.arrowFunctionExpression([t.objectPattern([t.objectProperty(t.identifier('params'), t.identifier('params'), false, true), t.restElement(t.identifier('queryClientParams'))])], t.arrowFunctionExpression([t.objectPattern([t.objectProperty(t.identifier('get'), t.identifier('get'), false, true)])], t.blockStatement([t.variableDeclaration('const', [t.variableDeclarator(t.identifier('client'), t.callExpression(t.identifier('get'), [t.callExpression(t.identifier('queryClient'), [t.identifier('queryClientParams')])]))]), t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.identifier('client'), t.identifier(methodName)), [t.spreadElement(t.identifier('params'))])))]), true)))])], t.tsTypeParameterInstantiation([t.tsTypeReference(t.identifier(responseType)), t.tsIntersectionType([t.tsTypeReference(t.identifier('QueryClientParams')), t.tsTypeLiteral([t.tsPropertySignature(t.identifier('params'), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Parameters'), t.tsTypeParameterInstantiation([t.tsIndexedAccessType(t.tsTypeReference(t.identifier(QueryClient)), t.tsLiteralType(t.stringLiteral(methodName)))]))))])])])))]));
 };
@@ -12,7 +11,8 @@ export const createRecoilSelectors = (context, keyPrefix, QueryClient, queryMsg)
   return getMessageProperties(queryMsg).map(schema => {
     const underscoreName = Object.keys(schema.properties)[0];
     const methodName = camel(underscoreName);
-    return createRecoilSelector(context, keyPrefix, QueryClient, methodName);
+    const responseType = getResponseType(context, underscoreName);
+    return createRecoilSelector(context, keyPrefix, QueryClient, methodName, responseType);
   });
 };
 export const createRecoilQueryClientType = () => ({

package/module/recoil/recoil.spec.js

@@ -1,11 +1,10 @@
 import * as t from '@babel/types';
 import query_msg from '../../../../__fixtures__/basic/query_msg.json';
 import { createRecoilSelector, createRecoilSelectors, createRecoilQueryClient } from './recoil';
-import { RenderContext } from '../context';
-import { expectCode } from '../../test-utils';
-const ctx = new RenderContext(query_msg);
+import { expectCode, makeContext } from '../../test-utils';
+const ctx = makeContext(query_msg);
 it('selector', () => {
-  expectCode(createRecoilSelector(ctx, 'SG721', 'SG721QueryClient', 'governanceModules'));
+  expectCode(createRecoilSelector(ctx, 'SG721', 'SG721QueryClient', 'governanceModules', 'GovernanceModulesResponse'));
 });
 it('selectors', () => {
   expectCode(t.program(createRecoilSelectors(ctx, 'SG721', 'SG721QueryClient', query_msg)));

package/module/utils/types.js

@@ -1,6 +1,12 @@
 import * as t from '@babel/types';
-import { camel } from 'case';
+import { camel, pascal } from 'case';
 import { propertySignature } from './babel';
+export function getResponseType(context, underscoreName) {
+  const methodName = camel(underscoreName);
+  return pascal(context.contract?.responses?.[underscoreName]?.title ?? // after v1.1 is adopted, we can deprecate this and require the above response
+  `${methodName}Response`);
+}
+;
 
 const getTypeStrFromRef = $ref => {
   if ($ref?.startsWith('#/definitions/')) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wasm-ast-types",
-  "version": "0.8.1",
+  "version": "0.10.0",
   "description": "CosmWasm TypeScript AST generation",
   "author": "Dan Lynch <pyramation@gmail.com>",
   "homepage": "https://github.com/pyramation/cosmwasm-typescript-gen/tree/master/packages/wasm-ast-types#readme",
@@ -86,5 +86,5 @@
     "case": "1.6.3",
     "deepmerge": "4.2.2"
   },
-  "gitHead": "548ad021d449f695ecc4f946a11e2ebe8af53780"
+  "gitHead": "94c5785d947e329df1cc9108cc33bb7a0c21af60"
 }

package/types/context/context.d.ts

@@ -5,6 +5,7 @@ export interface ReactQueryOptions {
     version?: 'v3' | 'v4';
     mutations?: boolean;
     camelize?: boolean;
+    queryKeys?: boolean;
 }
 export interface TSClientOptions {
     enabled?: boolean;
@@ -19,6 +20,25 @@ export interface TSTypesOptions {
     enabled?: boolean;
     aliasExecuteMsg?: boolean;
 }
+interface KeyedSchema {
+    [key: string]: JSONSchema;
+}
+export interface IDLObject {
+    contract_name: string;
+    contract_version: string;
+    idl_version: string;
+    instantiate: JSONSchema;
+    execute: JSONSchema;
+    query: JSONSchema;
+    migrate: JSONSchema;
+    sudo: JSONSchema;
+    responses: KeyedSchema;
+}
+export interface ContractInfo {
+    schemas: JSONSchema[];
+    responses?: Record<string, JSONSchema>;
+    idlObject?: IDLObject;
+}
 export interface RenderOptions {
     types?: TSTypesOptions;
     recoil?: RecoilOptions;
@@ -27,15 +47,18 @@ export interface RenderOptions {
     reactQuery?: ReactQueryOptions;
 }
 export interface RenderContext {
-    schema: JSONSchema;
+    contract: ContractInfo;
     options: RenderOptions;
 }
 export declare const defaultOptions: RenderOptions;
+export declare const getDefinitionSchema: (schemas: JSONSchema[]) => JSONSchema;
 export declare class RenderContext implements RenderContext {
-    schema: JSONSchema;
+    contract: ContractInfo;
     utils: string[];
-    constructor(schema: JSONSchema, options?: RenderOptions);
+    schema: JSONSchema;
+    constructor(contract: ContractInfo, options?: RenderOptions);
     refLookup($ref: string): JSONSchema;
     addUtil(util: string): void;
     getImports(): any[];
 }
+export {};

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

@@ -7,6 +7,7 @@ interface ReactQueryHookQuery {
     hookName: string;
     hookParamsTypeName: string;
     hookKeyName: string;
+    queryKeysName: string;
     responseType: string;
     methodName: string;
     jsonschema: any;
@@ -17,8 +18,8 @@ interface ReactQueryHooks {
     contractName: string;
     QueryClient: string;
 }
-export declare const createReactQueryHooks: ({ context, queryMsg, contractName, QueryClient }: ReactQueryHooks) => t.ExportNamedDeclaration[];
-export declare const createReactQueryHook: ({ context, hookName, hookParamsTypeName, responseType, hookKeyName, methodName, jsonschema }: ReactQueryHookQuery) => t.ExportNamedDeclaration;
+export declare const createReactQueryHooks: ({ context, queryMsg, contractName, QueryClient }: ReactQueryHooks) => any[];
+export declare const createReactQueryHook: ({ context, hookName, hookParamsTypeName, responseType, hookKeyName, queryKeysName, methodName, jsonschema }: ReactQueryHookQuery) => t.ExportNamedDeclaration;
 interface ReactQueryMutationHookInterface {
     context: RenderContext;
     ExecuteClient: string;

package/types/recoil/recoil.d.ts

@@ -1,7 +1,7 @@
 import * as t from '@babel/types';
 import { QueryMsg } from '../types';
 import { RenderContext } from '../context';
-export declare const createRecoilSelector: (context: RenderContext, keyPrefix: string, QueryClient: string, methodName: string) => t.ExportNamedDeclaration;
+export declare const createRecoilSelector: (context: RenderContext, keyPrefix: string, QueryClient: string, methodName: string, responseType: string) => t.ExportNamedDeclaration;
 export declare const createRecoilSelectors: (context: RenderContext, keyPrefix: string, QueryClient: string, queryMsg: QueryMsg) => any;
 export declare const createRecoilQueryClientType: () => {
     type: string;

package/types/utils/types.d.ts

@@ -2,6 +2,7 @@ import * as t from '@babel/types';
 import { TSTypeAnnotation } from '@babel/types';
 import { RenderContext } from '../context';
 import { JSONSchema } from '../types';
+export declare function getResponseType(context: RenderContext, underscoreName: string): string;
 export declare const getTypeFromRef: ($ref: any) => t.TSTypeReference;
 export declare const getType: (type: any) => t.TSBooleanKeyword | t.TSNumberKeyword | t.TSStringKeyword;
 export declare const getPropertyType: (context: RenderContext, schema: JSONSchema, prop: string) => {