wasm-ast-types 0.0.3

package/module/wasm.js

@@ -0,0 +1,233 @@
+import * as t from '@babel/types';
+import { camel, pascal } from 'case';
+import { bindMethod, typedIdentifier, promiseTypeAnnotation, classDeclaration, classProperty, arrowFunctionExpression } from './utils';
+
+const getTypeFromRef = $ref => {
+  switch ($ref) {
+    case '#/definitions/Binary':
+      return t.tsTypeReference(t.identifier('BinaryType'));
+
+    case '#/definitions/Expiration':
+      return t.tsTypeReference(t.identifier('Expiration'));
+
+    default:
+      if ($ref.startsWith('#/definitions/')) {
+        return t.tsTypeReference(t.identifier($ref.replace('#/definitions/', '')));
+      }
+
+      throw new Error('what is $ref: ' + $ref);
+  }
+};
+
+const getArrayTypeFromRef = $ref => {
+  return t.tsArrayType(getTypeFromRef($ref));
+};
+
+const getArrayTypeFromType = type => {
+  return t.tsArrayType(getType(type));
+};
+
+const getType = type => {
+  switch (type) {
+    case 'string':
+      return t.tsStringKeyword();
+
+    case 'boolean':
+      return t.tSBooleanKeyword();
+
+    case 'integer':
+      return t.tsNumberKeyword();
+
+    default:
+      throw new Error('what is type: ' + type);
+  }
+};
+
+const getPropertyType = (schema, prop) => {
+  const props = schema.properties ?? {};
+  let info = props[prop];
+  let type = null;
+  let optional = schema.required?.includes(prop);
+
+  if (info.allOf && info.allOf.length === 1) {
+    info = info.allOf[0];
+  }
+
+  if (typeof info.$ref === 'string') {
+    type = getTypeFromRef(info.$ref);
+  }
+
+  if (Array.isArray(info.anyOf)) {
+    // assuming 2nd is null, but let's check to ensure
+    if (info.anyOf.length !== 2) {
+      throw new Error('case not handled by transpiler. contact maintainers.');
+    }
+
+    const [nullableType, nullType] = info.anyOf;
+
+    if (nullType?.type !== 'null') {
+      throw new Error('case not handled by transpiler. contact maintainers.');
+    }
+
+    type = getTypeFromRef(nullableType?.$ref);
+    optional = true;
+  }
+
+  if (typeof info.type === 'string') {
+    if (info.type === 'array') {
+      if (info.items.$ref) {
+        type = getArrayTypeFromRef(info.items.$ref);
+      } else {
+        type = getArrayTypeFromType(info.items.type);
+      }
+    } else {
+      type = getType(info.type);
+    }
+  }
+
+  if (Array.isArray(info.type)) {
+    // assuming 2nd is null, but let's check to ensure
+    if (info.type.length !== 2) {
+      throw new Error('case not handled by transpiler. contact maintainers.');
+    }
+
+    const [nullableType, nullType] = info.type;
+
+    if (nullType !== 'null') {
+      throw new Error('case not handled by transpiler. contact maintainers.');
+    }
+
+    type = getType(nullableType);
+    optional = true;
+  }
+
+  if (!type) {
+    throw new Error('cannot find type for ' + JSON.stringify(info));
+  }
+
+  return {
+    type,
+    optional
+  };
+};
+
+const getProperty = (schema, prop) => {
+  const {
+    type,
+    optional
+  } = getPropertyType(schema, prop);
+  return typedIdentifier(camel(prop), t.tsTypeAnnotation(type), optional);
+};
+
+export const createWasmQueryMethod = jsonschema => {
+  const underscoreName = Object.keys(jsonschema.properties)[0];
+  const methodName = camel(underscoreName);
+  const responseType = pascal(`${methodName}Response`);
+  const properties = jsonschema.properties[underscoreName].properties ?? {}; // console.log({ jsonschema, methodName, underscoreName, properties });
+
+  const params = Object.keys(properties).map(prop => {
+    return getProperty(jsonschema.properties[underscoreName], prop);
+  });
+  const args = Object.keys(properties).map(prop => {
+    return t.objectProperty(t.identifier(prop), t.identifier(camel(prop)), false, true);
+  });
+  const actionArg = t.objectProperty(t.identifier(underscoreName), t.objectExpression(args));
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression(params, t.blockStatement([t.returnStatement(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('queryContractSmart')), [t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([actionArg])]))]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier(responseType))]))), true));
+};
+export const createQueryClass = (className, implementsClassName, queryMsg) => {
+  const propertyNames = queryMsg.oneOf.map(method => Object.keys(method.properties)?.[0]).filter(Boolean);
+  const bindings = propertyNames.map(camel).map(bindMethod);
+  const methods = queryMsg.oneOf.map(schema => {
+    return createWasmQueryMethod(schema);
+  });
+  return t.exportNamedDeclaration(classDeclaration(className, [// client
+  classProperty('client', t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CosmWasmClient')))), // contractAddress
+  classProperty('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword())), // constructor
+  t.classMethod('constructor', t.identifier('constructor'), [typedIdentifier('client', t.tsTypeAnnotation(t.tsTypeReference(t.identifier('CosmWasmClient')))), typedIdentifier('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword()))], t.blockStatement([// client/contract set
+  t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('client'))), t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.identifier('contractAddress'))), ...bindings])), ...methods], [t.tSExpressionWithTypeArguments(t.identifier(implementsClassName))]));
+};
+export const createWasmExecMethod = jsonschema => {
+  const underscoreName = Object.keys(jsonschema.properties)[0];
+  const methodName = camel(underscoreName);
+  const properties = jsonschema.properties[underscoreName].properties ?? {};
+  const params = Object.keys(properties).map(prop => {
+    return getProperty(jsonschema.properties[underscoreName], prop);
+  });
+  const args = Object.keys(properties).map(prop => {
+    return t.objectProperty(t.identifier(prop), t.identifier(camel(prop)), false, prop === camel(prop));
+  });
+  return t.classProperty(t.identifier(methodName), arrowFunctionExpression([// props
+  ...params], t.blockStatement([t.returnStatement(t.awaitExpression(t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('execute')), [t.memberExpression(t.thisExpression(), t.identifier('sender')), t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.objectExpression([t.objectProperty(t.identifier(underscoreName), t.objectExpression([...args]))]), t.stringLiteral('auto')])))]), // return type
+  t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([t.tSTypeReference(t.identifier('ExecuteResult'))]))), true));
+};
+export const createExecuteClass = (className, implementsClassName, extendsClassName, execMsg) => {
+  const propertyNames = execMsg.oneOf.map(method => Object.keys(method.properties)?.[0]).filter(Boolean);
+  const bindings = propertyNames.map(camel).map(bindMethod);
+  const methods = execMsg.oneOf.map(schema => {
+    return createWasmExecMethod(schema);
+  });
+  return t.exportNamedDeclaration(classDeclaration(className, [// client
+  classProperty('client', t.tsTypeAnnotation(t.tsTypeReference(t.identifier('SigningCosmWasmClient')))), // sender
+  classProperty('sender', t.tsTypeAnnotation(t.tsStringKeyword())), // contractAddress
+  classProperty('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword())), // constructor
+  t.classMethod('constructor', t.identifier('constructor'), [typedIdentifier('client', t.tsTypeAnnotation(t.tsTypeReference(t.identifier('SigningCosmWasmClient')))), typedIdentifier('sender', t.tsTypeAnnotation(t.tsStringKeyword())), typedIdentifier('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword()))], t.blockStatement([// super()
+  t.expressionStatement(t.callExpression(t.super(), [t.identifier('client'), t.identifier('contractAddress')])), // client/contract set
+  t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('client')), t.identifier('client'))), t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.identifier('contractAddress'))), ...bindings])), ...methods], [t.tSExpressionWithTypeArguments(t.identifier(implementsClassName))], t.identifier(extendsClassName)));
+};
+export const createExecuteInterface = (className, extendsClassName, execMsg) => {
+  const methods = execMsg.oneOf.map(jsonschema => {
+    const underscoreName = Object.keys(jsonschema.properties)[0];
+    const methodName = camel(underscoreName);
+    const properties = jsonschema.properties[underscoreName].properties ?? {};
+    const params = Object.keys(properties).map(prop => {
+      return getProperty(jsonschema.properties[underscoreName], prop);
+    });
+    return t.tSPropertySignature(t.identifier(methodName), t.tsTypeAnnotation(t.tsFunctionType(null, [...params], promiseTypeAnnotation('ExecuteResult'))));
+  });
+  return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(className), null, [t.tSExpressionWithTypeArguments(t.identifier(extendsClassName))], t.tSInterfaceBody([// contract address
+  t.tSPropertySignature(t.identifier('contractAddress'), t.tsTypeAnnotation(t.tsStringKeyword())), // contract address
+  t.tSPropertySignature(t.identifier('sender'), t.tsTypeAnnotation(t.tsStringKeyword())), ...methods])));
+};
+export const createQueryInterface = (className, queryMsg) => {
+  const methods = queryMsg.oneOf.map(jsonschema => {
+    const underscoreName = Object.keys(jsonschema.properties)[0];
+    const methodName = camel(underscoreName);
+    const responseType = pascal(`${methodName}Response`);
+    const properties = jsonschema.properties[underscoreName].properties ?? {};
+    const params = Object.keys(properties).map(prop => {
+      return getProperty(jsonschema.properties[underscoreName], prop);
+    });
+    return t.tSPropertySignature(t.identifier(methodName), t.tsTypeAnnotation(t.tsFunctionType(null, [...params], promiseTypeAnnotation(responseType))));
+  });
+  return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(className), null, [], t.tSInterfaceBody([t.tSPropertySignature(t.identifier('contractAddress'), t.tsTypeAnnotation(t.tsStringKeyword())), ...methods])));
+};
+export const propertySignature = (name, typeAnnotation, optional = false) => {
+  const prop = t.tsPropertySignature(t.identifier(name), typeAnnotation); // prop.leadingComments = [{
+  //   type: 'Comment',
+  //   value: ' Data on the token itself'
+  // }];
+  // prop.leadingComments = [{
+  //   type: 'CommentBlock',
+  //   value: '* Data on the token itself'
+  // }];
+
+  return prop;
+};
+export const createTypeOrInterface = (Type, jsonschema) => {
+  if (jsonschema.type !== 'object') {
+    return t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(Type), null, getType(jsonschema.type)));
+  }
+
+  const props = Object.keys(jsonschema.properties ?? {}).map(prop => {
+    const {
+      type,
+      optional
+    } = getPropertyType(jsonschema, prop);
+    return propertySignature(camel(prop), t.tsTypeAnnotation(type), optional);
+  });
+  return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(Type), null, [], t.tsInterfaceBody([...props])));
+};
+export const createTypeInterface = jsonschema => {
+  const Type = jsonschema.title;
+  return createTypeOrInterface(Type, jsonschema);
+};

package/module/wasm.spec.js

@@ -0,0 +1,69 @@
+import generate from '@babel/generator';
+import query_msg from './__fixtures__/schema/query_msg.json';
+import execute_msg from './__fixtures__/schema/execute_msg_for__empty.json';
+import approval_response from './__fixtures__/schema/approval_response.json';
+import all_nft_info_response from './__fixtures__/schema/all_nft_info_response.json';
+import approvals_response from './__fixtures__/schema/approvals_response.json';
+import collection_info_response from './__fixtures__/schema/collection_info_response.json';
+import contract_info_response from './__fixtures__/schema/contract_info_response.json';
+import instantiate_msg from './__fixtures__/schema/instantiate_msg.json';
+import nft_info_response from './__fixtures__/schema/nft_info_response.json';
+import num_tokens_response from './__fixtures__/schema/num_tokens_response.json';
+import operators_response from './__fixtures__/schema/operators_response.json';
+import owner_of_response from './__fixtures__/schema/owner_of_response.json';
+import tokens_response from './__fixtures__/schema/tokens_response.json';
+import { createQueryClass, createQueryInterface, createExecuteClass, createExecuteInterface, createTypeInterface } from './wasm';
+
+const expectCode = ast => {
+  expect(generate(ast).code).toMatchSnapshot();
+};
+
+const printCode = ast => {
+  console.log(generate(ast).code);
+};
+
+it('approval_response', () => {
+  expectCode(createTypeInterface(approval_response));
+});
+it('all_nft_info_response', () => {
+  expectCode(createTypeInterface(all_nft_info_response));
+});
+it('approvals_response', () => {
+  expectCode(createTypeInterface(approvals_response));
+});
+it('collection_info_response', () => {
+  expectCode(createTypeInterface(collection_info_response));
+});
+it('contract_info_response', () => {
+  expectCode(createTypeInterface(contract_info_response));
+});
+it('instantiate_msg', () => {
+  expectCode(createTypeInterface(instantiate_msg));
+});
+it('nft_info_response', () => {
+  expectCode(createTypeInterface(nft_info_response));
+});
+it('num_tokens_response', () => {
+  expectCode(createTypeInterface(num_tokens_response));
+});
+it('operators_response', () => {
+  expectCode(createTypeInterface(operators_response));
+});
+it('owner_of_response', () => {
+  expectCode(createTypeInterface(owner_of_response));
+});
+it('tokens_response', () => {
+  expectCode(createTypeInterface(tokens_response));
+});
+it('query classes', () => {
+  expectCode(createQueryClass('SG721QueryClient', 'SG721ReadOnlyInstance', query_msg));
+});
+it('execute classes', () => {
+  expectCode(createExecuteClass('SG721Client', 'SG721Instance', 'SG721QueryClient', execute_msg));
+});
+it('execute interfaces', () => {
+  expectCode(createExecuteInterface('SG721Instance', 'SG721ReadOnlyInstance', execute_msg));
+});
+it('query interfaces', () => {
+  expectCode(createQueryInterface('SG721ReadOnlyInstance', query_msg));
+});

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "wasm-ast-types",
+  "version": "0.0.3",
+  "description": "CosmWasm TypeScript AST generation",
+  "author": "Dan Lynch <pyramation@gmail.com>",
+  "homepage": "https://github.com/pyramation/cosmscript/tree/master/packages/wasm-ast-types#readme",
+  "license": "SEE LICENSE IN LICENSE",
+  "main": "main/index.js",
+  "module": "module/index.js",
+  "typings": "types/index.d.ts",
+  "directories": {
+    "lib": "src",
+    "test": "__tests__"
+  },
+  "files": [
+    "types",
+    "main",
+    "module"
+  ],
+  "scripts": {
+    "build:main": "cross-env BABEL_ENV=production babel src --out-dir main --delete-dir-on-start --extensions \".tsx,.ts,.js\"",
+    "build:module": "cross-env MODULE=true babel src --out-dir module --delete-dir-on-start  --extensions \".tsx,.ts,.js\"",
+    "build": "npm run build:module && npm run build:main",
+    "build:ts": "tsc --project ./tsconfig.json",
+    "prepare": "npm run build",
+    "dev": "cross-env NODE_ENV=development babel-node src/index",
+    "watch": "cross-env NODE_ENV=development babel-watch src/index",
+    "lint": "eslint src --fix",
+    "test": "jest",
+    "test:ast": "cross-env NODE_ENV=development babel-node scripts/test-ast.js",
+    "test:watch": "jest --watch",
+    "test:debug": "node --inspect node_modules/.bin/jest --runInBand"
+  },
+  "jest": {
+    "testPathIgnorePatterns": [
+      "main/",
+      "module/"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/pyramation/cosmscript/tree/master/packages/wasm-ast-types"
+  },
+  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/pyramation/cosmscript/tree/master/packages/wasm-ast-types/issues"
+  },
+  "devDependencies": {
+    "@babel/cli": "7.17.6",
+    "@babel/core": "7.17.8",
+    "@babel/eslint-parser": "^7.5.4",
+    "@babel/generator": "7.17.7",
+    "@babel/node": "^7.10.5",
+    "@babel/parser": "^7.17.8",
+    "@babel/plugin-proposal-class-properties": "7.16.7",
+    "@babel/plugin-proposal-export-default-from": "7.16.7",
+    "@babel/plugin-proposal-object-rest-spread": "7.17.3",
+    "@babel/plugin-transform-runtime": "7.17.0",
+    "@babel/preset-env": "7.16.11",
+    "@babel/preset-typescript": "^7.16.7",
+    "@babel/traverse": "7.17.3",
+    "@types/jest": "^27.4.1",
+    "babel-core": "7.0.0-bridge.0",
+    "babel-jest": "27.5.1",
+    "babel-watch": "^7.0.0",
+    "cross-env": "^7.0.2",
+    "eslint": "8.12.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-prettier": "^4.0.0",
+    "glob": "7.2.0",
+    "jest": "^27.5.1",
+    "jest-in-case": "^1.0.2",
+    "mkdirp": "1.0.4",
+    "prettier": "^2.6.2",
+    "regenerator-runtime": "^0.13.7",
+    "ts-jest": "^27.1.4",
+    "typescript": "^4.6.2"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.11.2",
+    "@babel/types": "7.17.0",
+    "ast-stringify": "0.1.0",
+    "case": "1.6.3"
+  },
+  "gitHead": "bb157d67d9adbf04328fdcfcfb37aab0bc336c4e"
+}

package/types/amino/amino-interfaces.d.ts

@@ -0,0 +1,6 @@
+import * as t from '@babel/types';
+import { Enum, Field, Interface, MessageSchema } from '../types';
+export declare const makeAminoConverterItem: (schema: MessageSchema, enums: Enum[], interfaces: Interface[]) => t.ObjectProperty;
+export declare const aminoConverter: (schemas: MessageSchema[], enums: Enum[], interfaces: Interface[]) => t.ExportNamedDeclaration;
+export declare const renderAminoField: (field: Field, enums: Enum[], interfaces?: any[], imports?: any[]) => any;
+export declare const makeAminoTypeInterface: (schema: MessageSchema, enums: Enum[], interfaces?: any[], imports?: any[]) => t.ExportNamedDeclaration;

package/types/amino/from-amino.d.ts

@@ -0,0 +1,13 @@
+import * as t from '@babel/types';
+import { Enum, Field, Interface, MessageSchema } from '../types';
+export declare const fromAminoStringToLong: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const fromAminoFromArrayCall: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const fromAminoSnakeToCamel: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const fromAminoHeight: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const fromAminoDuration: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const fromAminoEnum: (val: Enum, field: Field, scope: string[]) => t.ObjectProperty;
+export declare const fromAminoEnumArray: (val: Enum, field: Field, scope: string[]) => t.ObjectProperty;
+export declare const fromAminoInterface: (field: Field, ival: Interface, enums: Enum[], interfaces: Interface[], scope: string[], nested: number) => any;
+export declare const fromAminoInterfaceArray: (field: Field, ival: Interface, enums: Enum[], interfaces: Interface[], scope: string[], nested: number) => t.ObjectProperty;
+export declare const fromAminoParseField: (field: Field, enums: Enum[], interfaces: Interface[], scope?: any[], nested?: number) => any;
+export declare const fromAmino: (schema: MessageSchema, enums: Enum[], interfaces: Interface[]) => t.ArrowFunctionExpression;

package/types/amino/index.d.ts

@@ -0,0 +1,3 @@
+export * from './from-amino';
+export * from './to-amino';
+export * from './amino-interfaces';

package/types/amino/to-amino.d.ts

@@ -0,0 +1,11 @@
+import * as t from '@babel/types';
+import { Enum, Field, Interface, MessageSchema } from '../types';
+export declare const toAminoDuration: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const toAminoSnakeToCamel: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const toAminoInterface: (field: Field, ival: Interface, enums: Enum[], interfaces: Interface[], scope: string[], nested: number) => any;
+export declare const toAminoInterfaceArray: (field: Field, ival: Interface, enums: Enum[], interfaces: Interface[], scope: string[], nested: number) => t.ObjectProperty;
+export declare const toAminoLongToString: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const toAminoCoin: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const toAminoHeight: (prop: string, scope: string[]) => t.ObjectProperty;
+export declare const toAminoParseField: (field: Field, enums: Enum[], interfaces: Interface[], scope?: any[], nested?: number) => any;
+export declare const toAmino: (schema: MessageSchema, enums: Enum[], interfaces: Interface[]) => t.ArrowFunctionExpression;

package/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './utils';
+export * from './wasm';

package/types/messages.d.ts

@@ -0,0 +1,35 @@
+import * as t from '@babel/types';
+import { Mutation } from './types';
+export declare const addMsgMethod: ({ methodName, typeUrl, TypeName, methodToCall }: {
+    methodName: any;
+    typeUrl: any;
+    TypeName: any;
+    methodToCall: any;
+}) => t.ObjectMethod;
+export declare const addFromJSONMethod: ({ methodName, typeUrl, TypeName }: {
+    methodName: any;
+    typeUrl: any;
+    TypeName: any;
+}) => t.ObjectMethod;
+export declare const addFromPartialMethod: ({ methodName, typeUrl, TypeName }: {
+    methodName: any;
+    typeUrl: any;
+    TypeName: any;
+}) => t.ObjectMethod;
+export declare const addToJSONMethod: ({ methodName, typeUrl, TypeName }: {
+    methodName: any;
+    typeUrl: any;
+    TypeName: any;
+}) => t.ObjectMethod;
+export declare const addJsonMethod: ({ methodName, typeUrl, TypeName }: {
+    methodName: any;
+    typeUrl: any;
+    TypeName: any;
+}) => t.ObjectMethod;
+export declare const addEncodedMethod: ({ methodName, typeUrl, TypeName }: {
+    methodName: any;
+    typeUrl: any;
+    TypeName: any;
+}) => t.ObjectMethod;
+export declare const messages: (mutations: Mutation[]) => t.ExportNamedDeclaration;
+export declare const encoded: (mutations: Mutation[]) => t.ExportNamedDeclaration;

package/types/types.d.ts

@@ -0,0 +1,10 @@
+export declare type fieldType = 'Long' | 'Coin' | 'Duration' | 'Height' | string;
+export interface Field {
+    name: string;
+    type: fieldType;
+    node: any;
+}
+export interface Interface {
+    name: string;
+    fields: Field[];
+}

package/types/utils.d.ts

@@ -0,0 +1,29 @@
+import * as t from '@babel/types';
+import { Field } from './types';
+import { TSTypeAnnotation, TSExpressionWithTypeArguments } from '@babel/types';
+export declare const bindMethod: (name: string) => t.ExpressionStatement;
+export declare const typedIdentifier: (name: string, typeAnnotation: TSTypeAnnotation, optional?: boolean) => t.Identifier;
+export declare const promiseTypeAnnotation: (name: any) => t.TSTypeAnnotation;
+export declare const classDeclaration: (name: string, body: any[], implementsExressions?: TSExpressionWithTypeArguments[], superClass?: t.Identifier) => t.ClassDeclaration;
+export declare const classProperty: (name: string, typeAnnotation?: TSTypeAnnotation, isReadonly?: boolean, isStatic?: boolean) => t.ClassProperty;
+export declare const arrowFunctionExpression: (params: (t.Identifier | t.Pattern | t.RestElement)[], body: t.BlockStatement, returnType: t.TSTypeAnnotation, isAsync?: boolean) => t.ArrowFunctionExpression;
+export declare const recursiveNamespace: (names: any, moduleBlockBody: any) => any;
+export declare const arrayTypeNDimensions: (body: any, n: any) => any;
+export declare const FieldTypeAsts: {
+    string: () => t.TSStringKeyword;
+    array: (type: any) => t.TSArrayType;
+    Duration: () => t.TSTypeReference;
+    Height: () => t.TSTypeReference;
+    Coin: () => t.TSTypeReference;
+    Long: () => t.TSTypeReference;
+};
+export declare const shorthandProperty: (prop: string) => t.ObjectProperty;
+export declare const importStmt: (names: string[], path: string) => t.ImportDeclaration;
+export declare const importAminoMsg: () => t.ImportDeclaration;
+export declare const getFieldDimensionality: (field: Field) => {
+    typeName: string;
+    dimensions: number;
+    isArray: boolean;
+};
+export declare const memberExpressionOrIdentifier: (names: any) => any;
+export declare const memberExpressionOrIdentifierSnake: (names: any) => any;

package/types/wasm.d.ts

@@ -0,0 +1,21 @@
+import * as t from '@babel/types';
+interface QueryMsg {
+    $schema: string;
+    title: "QueryMsg";
+    oneOf: any;
+}
+interface ExecuteMsg {
+    $schema: string;
+    title: "ExecuteMsg" | "ExecuteMsg_for_Empty";
+    oneOf: any;
+}
+export declare const createWasmQueryMethod: (jsonschema: any) => t.ClassProperty;
+export declare const createQueryClass: (className: string, implementsClassName: string, queryMsg: QueryMsg) => t.ExportNamedDeclaration;
+export declare const createWasmExecMethod: (jsonschema: any) => t.ClassProperty;
+export declare const createExecuteClass: (className: string, implementsClassName: string, extendsClassName: string, execMsg: ExecuteMsg) => t.ExportNamedDeclaration;
+export declare const createExecuteInterface: (className: string, extendsClassName: string, execMsg: ExecuteMsg) => t.ExportNamedDeclaration;
+export declare const createQueryInterface: (className: string, queryMsg: QueryMsg) => t.ExportNamedDeclaration;
+export declare const propertySignature: (name: string, typeAnnotation: t.TSTypeAnnotation, optional?: boolean) => t.TSPropertySignature;
+export declare const createTypeOrInterface: (Type: string, jsonschema: any) => t.ExportNamedDeclaration;
+export declare const createTypeInterface: (jsonschema: any) => t.ExportNamedDeclaration;
+export {};