wasm-ast-types 0.26.4 → 1.0.0

package/esm/utils/babel.js

@@ -0,0 +1,231 @@
+import * as t from '@babel/types';
+import { snake } from "case";
+import { refLookup } from './ref';
+// t.TSPropertySignature - kind?
+export const propertySignature = (name, typeAnnotation, optional = false) => {
+    return {
+        type: 'TSPropertySignature',
+        key: t.identifier(name),
+        kind: 'get',
+        typeAnnotation,
+        optional
+    };
+};
+export const identifier = (name, typeAnnotation, optional = false) => {
+    const type = t.identifier(name);
+    type.typeAnnotation = typeAnnotation;
+    type.optional = optional;
+    return type;
+};
+export const tsTypeOperator = (typeAnnotation, operator) => {
+    const obj = t.tsTypeOperator(typeAnnotation);
+    obj.operator = operator;
+    return obj;
+};
+export const getMessageProperties = (msg) => {
+    let results = [];
+    let objs = [];
+    if (msg.anyOf) {
+        objs = msg.anyOf;
+    }
+    else if (msg.oneOf) {
+        objs = msg.oneOf;
+    }
+    else if (msg.allOf) {
+        objs = msg.allOf;
+    }
+    for (const obj of objs) {
+        if (obj.properties) {
+            results.push(obj);
+        }
+        else {
+            if (obj.$ref) {
+                const ref = refLookup(obj.$ref, msg);
+                const refProps = getMessageProperties(ref);
+                results = [...results, ...refProps];
+            }
+        }
+    }
+    return results;
+};
+export const tsPropertySignature = (key, typeAnnotation, optional) => {
+    const obj = t.tsPropertySignature(key, typeAnnotation);
+    obj.optional = optional;
+    return obj;
+};
+export const tsObjectPattern = (properties, typeAnnotation) => {
+    const obj = t.objectPattern(properties);
+    obj.typeAnnotation = typeAnnotation;
+    return obj;
+};
+export const callExpression = (callee, _arguments, typeParameters) => {
+    const callExpr = t.callExpression(callee, _arguments);
+    callExpr.typeParameters = typeParameters;
+    return callExpr;
+};
+export const bindMethod = (name) => {
+    return t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier(name)), t.callExpression(t.memberExpression(t.memberExpression(t.thisExpression(), t.identifier(name)), t.identifier('bind')), [
+        t.thisExpression()
+    ])));
+};
+export const typedIdentifier = (name, typeAnnotation, optional = false) => {
+    const type = t.identifier(name);
+    type.typeAnnotation = typeAnnotation;
+    type.optional = optional;
+    return type;
+};
+export const promiseTypeAnnotation = (name) => {
+    return t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([
+        t.tsTypeReference(t.identifier(name))
+    ])));
+};
+export const abstractClassDeclaration = (name, body, implementsExressions = [], superClass = null) => {
+    const declaration = classDeclaration(name, body, implementsExressions, superClass);
+    declaration.abstract = true;
+    return declaration;
+};
+export const classDeclaration = (name, body, implementsExressions = [], superClass = null) => {
+    const declaration = t.classDeclaration(t.identifier(name), superClass, t.classBody(body));
+    if (implementsExressions.length) {
+        declaration.implements = implementsExressions;
+    }
+    return declaration;
+};
+export const classProperty = (name, typeAnnotation = null, isReadonly = false, isStatic = false, noImplicitOverride = false) => {
+    const prop = t.classProperty(t.identifier(name));
+    if (isReadonly)
+        prop.readonly = true;
+    if (isStatic)
+        prop.static = true;
+    if (typeAnnotation)
+        prop.typeAnnotation = typeAnnotation;
+    if (noImplicitOverride)
+        prop.override = true;
+    return prop;
+};
+export const arrowFunctionExpression = (params, body, returnType, isAsync = false) => {
+    const func = t.arrowFunctionExpression(params, body, isAsync);
+    if (returnType)
+        func.returnType = returnType;
+    return func;
+};
+export const recursiveNamespace = (names, moduleBlockBody) => {
+    if (!names || !names.length)
+        return moduleBlockBody;
+    const name = names.pop();
+    const body = [
+        t.exportNamedDeclaration(t.tsModuleDeclaration(t.identifier(name), t.tsModuleBlock(recursiveNamespace(names, moduleBlockBody))))
+    ];
+    return body;
+};
+export const arrayTypeNDimensions = (body, n) => {
+    if (!n)
+        return t.tsArrayType(body);
+    return t.tsArrayType(arrayTypeNDimensions(body, n - 1));
+};
+export const FieldTypeAsts = {
+    string: () => {
+        return t.tsStringKeyword();
+    },
+    array: (type) => {
+        const result = FieldTypeAsts[type]();
+        return t.tsArrayType(result);
+    },
+    Duration: () => {
+        return t.tsTypeReference(t.identifier('Duration'));
+    },
+    Height: () => {
+        return t.tsTypeReference(t.identifier('Height'));
+    },
+    Coin: () => {
+        return t.tsTypeReference(t.identifier('Coin'));
+    },
+    Long: () => {
+        return t.tsTypeReference(t.identifier('Long'));
+    }
+};
+export const shorthandProperty = (prop) => {
+    return t.objectProperty(t.identifier(prop), t.identifier(prop), false, true);
+};
+export const importStmt = (names, path) => {
+    return t.importDeclaration(names.map(name => t.importSpecifier(t.identifier(name), t.identifier(name))), t.stringLiteral(path));
+};
+export const importAs = (name, importAs, importPath) => {
+    return t.importDeclaration([
+        t.importSpecifier(t.identifier(importAs), t.identifier(name))
+    ], t.stringLiteral(importPath));
+};
+export const importAminoMsg = () => {
+    return importStmt(['AminoMsg'], '@cosmjs/amino');
+};
+export const getFieldDimensionality = (field) => {
+    let typeName = field.type;
+    const isArray = typeName.endsWith('[]');
+    let dimensions = 0;
+    if (isArray) {
+        dimensions = typeName.match(/\[\]/g).length - 1;
+        typeName = typeName.replace(/\[\]/g, '');
+    }
+    return {
+        typeName,
+        dimensions,
+        isArray
+    };
+};
+export const memberExpressionOrIdentifier = (names) => {
+    if (names.length === 1) {
+        return t.identifier(names[0]);
+    }
+    if (names.length === 2) {
+        const [b, a] = names;
+        return t.memberExpression(t.identifier(a), t.identifier(b));
+    }
+    const [name, ...rest] = names;
+    return t.memberExpression(memberExpressionOrIdentifier(rest), t.identifier(name));
+};
+export const memberExpressionOrIdentifierSnake = (names) => {
+    if (names.length === 1) {
+        return t.identifier(snake(names[0]));
+    }
+    if (names.length === 2) {
+        const [b, a] = names;
+        return t.memberExpression(t.identifier(snake(a)), t.identifier(snake(b)));
+    }
+    const [name, ...rest] = names;
+    return t.memberExpression(memberExpressionOrIdentifierSnake(rest), t.identifier(snake(name)));
+};
+/**
+ * If optional, return a conditional, otherwise just the expression
+ */
+export const optionalConditionalExpression = (test, expression, alternate, optional = false) => {
+    return optional
+        ? t.conditionalExpression(test, expression, alternate)
+        : expression;
+};
+export const typeRefOrUnionWithUndefined = (identifier, optional = false) => {
+    const typeReference = t.tsTypeReference(identifier);
+    return optional
+        ? t.tsUnionType([
+            typeReference,
+            t.tsUndefinedKeyword()
+        ])
+        : typeReference;
+};
+export const parameterizedTypeReference = (identifier, from, omit) => {
+    return t.tsTypeReference(t.identifier(identifier), t.tsTypeParameterInstantiation([
+        from,
+        typeof omit === 'string'
+            ? t.tsLiteralType(t.stringLiteral(omit))
+            : t.tsUnionType(omit.map(o => t.tsLiteralType(t.stringLiteral(o))))
+    ]));
+};
+/**
+ * omitTypeReference(t.tsTypeReference(t.identifier('Cw4UpdateMembersMutation'),),'args').....
+ * Omit<Cw4UpdateMembersMutation, 'args'>
+ */
+export const omitTypeReference = (from, omit) => {
+    return parameterizedTypeReference('Omit', from, omit);
+};
+export const pickTypeReference = (from, pick) => {
+    return parameterizedTypeReference('Pick', from, pick);
+};

package/esm/utils/constants.js

@@ -0,0 +1,20 @@
+import { identifier } from './babel';
+import * as t from '@babel/types';
+export const OPTIONAL_FUNDS_PARAM = identifier('_funds', t.tsTypeAnnotation(t.tsArrayType(t.tsTypeReference(t.identifier('Coin')))), true);
+export const OPTIONAL_FEE_PARAM = identifier('fee', t.tsTypeAnnotation(t.tsUnionType([
+    t.tsNumberKeyword(),
+    t.tsTypeReference(t.identifier('StdFee')),
+    t.tsLiteralType(t.stringLiteral('auto'))
+])), true);
+export const OPTIONAL_MEMO_PARAM = identifier('memo', t.tsTypeAnnotation(t.tsStringKeyword()), true);
+export const FIXED_EXECUTE_PARAMS = [
+    OPTIONAL_FEE_PARAM,
+    OPTIONAL_MEMO_PARAM,
+    OPTIONAL_FUNDS_PARAM
+];
+export const PROVIDER_TYPES = {
+    SIGNING_CLIENT_TYPE: "client",
+    QUERY_CLIENT_TYPE: "queryClient",
+    MESSAGE_COMPOSER_TYPE: 'message-composer',
+    PROVIDER_TYPE: 'provider'
+};

package/esm/utils/ref.js

@@ -0,0 +1,4 @@
+export const refLookup = ($ref, schema) => {
+    const refName = $ref.replace('#/definitions/', '');
+    return schema.definitions?.[refName];
+};

package/esm/utils/types.js

@@ -0,0 +1,343 @@
+import * as t from '@babel/types';
+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/')) {
+        return $ref.replace('#/definitions/', '');
+    }
+    throw new Error('what is $ref: ' + $ref);
+};
+export const getTypeFromRef = ($ref) => {
+    return t.tsTypeReference(t.identifier(getTypeStrFromRef($ref)));
+};
+const getArrayTypeFromRef = ($ref) => {
+    return t.tsArrayType(getTypeFromRef($ref));
+};
+export const getTypeOrRef = (obj) => {
+    if (obj.$ref) {
+        return getTypeFromRef(obj.$ref);
+    }
+    else if (typeof obj.type === 'string') {
+        return getType(obj.type);
+    }
+    else if (Array.isArray(obj.type)) {
+        // Handle array of types by creating a union type
+        const types = obj.type.map(t => getType(t));
+        return t.tsUnionType(types);
+    }
+    else {
+        throw new Error('Type definition not supported or missing: ' + JSON.stringify(obj));
+    }
+};
+const getArrayTypeFromItems = (context, items) => {
+    if (Array.isArray(items)) {
+        // if (context.options.types.itemsUseTuples === true) {
+        // Using the modified method with tsTupleType
+        // return t.tsArrayType(
+        // t.tsTupleType(items.map(item => getTypeOrRef(item)))
+        // );
+        // } else {
+        // Using the original method with nested arrays
+        if (items.length > 0 && items[0].type === 'array') {
+            return getArrayTypeFromItems(context, items[0]);
+        }
+        return items.length > 0 ? t.tsArrayType(t.tsArrayType(getTypeOrRef(items[0]))) : t.tsArrayType(t.tsArrayType(t.tsAnyKeyword()));
+        // }
+    }
+    else {
+        const detect = detectType(items.type);
+        if (detect.type === 'array') {
+            if (Array.isArray(items.items)) {
+                return t.tsArrayType(t.tsArrayType(getTypeOrRef(items.items[0])));
+            }
+            else if (items.items) {
+                return t.tsArrayType(getArrayTypeFromItems(context, items.items));
+            }
+            else {
+                // Handle the case where items.items is undefined for array types
+                return t.tsArrayType(t.tsAnyKeyword());
+            }
+        }
+        return t.tsArrayType(getType(detect.type));
+    }
+};
+export const detectType = (type) => {
+    let optional = false;
+    let theType = '';
+    if (Array.isArray(type)) {
+        if (type.length !== 2) {
+            throw new Error('[getType(array length)] case not handled by transpiler. contact maintainers.');
+        }
+        const [nullableType, nullType] = type;
+        if (nullType !== 'null') {
+            throw new Error('[getType(null)] case not handled by transpiler. contact maintainers.');
+        }
+        theType = nullableType;
+        optional = true;
+    }
+    else {
+        theType = type;
+    }
+    return {
+        type: theType,
+        optional
+    };
+};
+export const getTypeInfo = (context, info) => {
+    let type = undefined;
+    let optional = undefined;
+    // Handle nullable types using 'anyOf' schema
+    if (Array.isArray(info.anyOf)) {
+        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('[nullableType.type]: case not handled by transpiler. contact maintainers.');
+        }
+        if (!nullableType?.$ref) {
+            if (nullableType.title) {
+                type = t.tsTypeReference(t.identifier(nullableType.title));
+            }
+            else {
+                throw new Error('[nullableType.title] case not handled by transpiler. contact maintainers.');
+            }
+        }
+        else {
+            type = getTypeFromRef(nullableType.$ref);
+        }
+        optional = true;
+    }
+    else if (typeof info.type === 'string') {
+        // Process type when it's explicitly defined
+        if (info.type === 'array') {
+            if (typeof info.items === 'object' && !Array.isArray(info.items)) {
+                if (info.items.$ref) {
+                    type = getArrayTypeFromRef(info.items.$ref);
+                }
+                else if (info.items.title) {
+                    type = t.tsArrayType(t.tsTypeReference(t.identifier(info.items.title)));
+                }
+                else if (info.items.type) {
+                    type = getArrayTypeFromItems(context, info.items);
+                }
+                else {
+                    throw new Error('[info.items] case not handled by transpiler. contact maintainers.');
+                }
+                // type = getArrayTypeFromItems(context, info.items);
+            }
+            else {
+                if (Array.isArray(info.items)) {
+                    type = getArrayTypeFromItems(context, info.items);
+                }
+                else {
+                    throw new Error('[info.items] case not handled by transpiler. contact maintainers.');
+                }
+            }
+        }
+        else {
+            const detect = detectType(info.type);
+            type = getType(detect.type);
+            optional = detect.optional;
+        }
+    }
+    else if (Array.isArray(info.type)) {
+        // Handle multiple types, typically nullable types
+        if (info.type.length !== 2) {
+            throw new Error('please report this to maintainers (field type): ' + JSON.stringify(info, null, 2));
+        }
+        const [nullableType, nullType] = info.type;
+        if (nullType !== 'null') {
+            throw new Error('please report this to maintainers (field type): ' + JSON.stringify(info, null, 2));
+        }
+        if (nullableType === 'array' && typeof info.items === 'object' && !Array.isArray(info.items)) {
+            if (info.items.type) {
+                const detect = detectType(info.items.type);
+                if (detect.type === 'array') {
+                    type = t.tsArrayType(getArrayTypeFromItems(context, info.items));
+                }
+                else {
+                    type = t.tsArrayType(getType(detect.type));
+                }
+                optional = detect.optional;
+            }
+            else if (info.items.$ref) {
+                type = getArrayTypeFromRef(info.items.$ref);
+            }
+            else if (info.items.type) {
+                type = getArrayTypeFromItems(context, info.items);
+            }
+            else {
+                throw new Error('[info.items] case not handled by transpiler. contact maintainers.');
+            }
+        }
+        else {
+            const detect = detectType(nullableType);
+            optional = detect.optional;
+            if (detect.type === 'array') {
+                type = getArrayTypeFromItems(context, info.items);
+            }
+            else {
+                type = getType(detect.type);
+            }
+        }
+        optional = true; // Ensure optional is set for nullable types
+    }
+    return {
+        type,
+        optional
+    };
+};
+export const getType = (type) => {
+    switch (type) {
+        case 'string':
+            return t.tsStringKeyword();
+        case 'boolean':
+            return t.tSBooleanKeyword();
+        case 'integer':
+            return t.tsNumberKeyword();
+        case 'null':
+            return t.tsNullKeyword();
+        case 'number':
+            return t.tsNumberKeyword();
+        default:
+            throw new Error('contact maintainers [unknown type]: ' + type);
+    }
+};
+export const getPropertyType = (context, 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);
+    }
+    const typeInfo = getTypeInfo(context, info);
+    if (typeof typeInfo.optional !== 'undefined') {
+        optional = typeInfo.optional;
+    }
+    if (typeof typeInfo.type !== 'undefined') {
+        type = typeInfo.type;
+    }
+    if (!type) {
+        throw new Error('cannot find type for ' + JSON.stringify(info));
+    }
+    if (schema.required?.includes(prop)) {
+        optional = false;
+    }
+    return { type, optional };
+};
+export function getPropertySignatureFromProp(context, jsonschema, prop, camelize) {
+    if (jsonschema.properties[prop].type === 'object') {
+        if (jsonschema.properties[prop].title) {
+            return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsTypeReference(t.identifier(jsonschema.properties[prop].title))));
+        }
+        else {
+            throw new Error('getPropertySignatureFromProp() contact maintainer');
+        }
+    }
+    if (Array.isArray(jsonschema.properties[prop].allOf)) {
+        const isOptional = !jsonschema.required?.includes(prop);
+        const unionTypes = jsonschema.properties[prop].allOf.map(el => {
+            if (el.title)
+                return el.title;
+            if (el.$ref)
+                return getTypeStrFromRef(el.$ref);
+            return el.type;
+        }).filter(a => typeof a === 'string');
+        // ONLY SUPPORT string types for now!
+        // e.g. NOT supporting nullable types or type: string[] yet
+        // @ts-ignore:next-line
+        const uniqUnionTypes = [...new Set(unionTypes)];
+        if (uniqUnionTypes.length === 1) {
+            return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsTypeReference(t.identifier(uniqUnionTypes[0]))), isOptional);
+        }
+        else {
+            return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsUnionType(uniqUnionTypes.map(typ => t.tsTypeReference(t.identifier(typ))))), isOptional);
+        }
+    }
+    else if (Array.isArray(jsonschema.properties[prop].oneOf)) {
+        const isOptional = !jsonschema.required?.includes(prop);
+        const unionTypes = jsonschema.properties[prop].oneOf.map(el => {
+            if (el.title)
+                return el.title;
+            if (el.$ref)
+                return getTypeStrFromRef(el.$ref);
+            return el.type;
+        }).filter(a => typeof a === 'string');
+        // ONLY SUPPORT string types for now!
+        // e.g. NOT supporting nullable types or type: string[] yet
+        const uniqUnionTypes = [...new Set(unionTypes)];
+        if (uniqUnionTypes.length === 1) {
+            return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsTypeReference(t.identifier(uniqUnionTypes[0]))), isOptional);
+        }
+        else {
+            return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(t.tsUnionType(uniqUnionTypes.map(typ => t.tsTypeReference(t.identifier(typ))))), isOptional);
+        }
+    }
+    try {
+        getPropertyType(context, jsonschema, prop);
+    }
+    catch (e) {
+        console.log(e);
+        console.log(JSON.stringify(jsonschema, null, 2), prop);
+    }
+    const { type, optional } = getPropertyType(context, jsonschema, prop);
+    return propertySignature(camelize ? camel(prop) : prop, t.tsTypeAnnotation(type), optional);
+}
+export const getParamsTypeAnnotation = (context, jsonschema, camelize = true) => {
+    const keys = Object.keys(jsonschema.properties ?? {});
+    if (!keys.length && jsonschema.$ref) {
+        return t.tsTypeAnnotation(getTypeFromRef(jsonschema.$ref));
+    }
+    if (!keys.length)
+        return undefined;
+    const typedParams = keys.map(prop => getPropertySignatureFromProp(context, jsonschema, prop, camelize));
+    return t.tsTypeAnnotation(t.tsTypeLiteral(
+    // @ts-ignore:next-line
+    [
+        ...typedParams
+    ]));
+};
+export const createTypedObjectParams = (context, jsonschema, camelize = true) => {
+    const keys = Object.keys(jsonschema.properties ?? {});
+    if (!keys.length) {
+        // is there a ref?
+        if (jsonschema.$ref) {
+            const obj = context.refLookup(jsonschema.$ref);
+            // If there is a oneOf, then we need to create a type for it
+            if (obj?.oneOf) {
+                // the actual type of the ref
+                const refType = jsonschema.$ref.split('/').pop();
+                const refName = camel(refType);
+                const id = t.identifier(refName);
+                id.typeAnnotation = t.tsTypeAnnotation(t.tsTypeReference(t.identifier(refType)));
+                return id;
+            }
+            else if (obj) {
+                return createTypedObjectParams(context, obj, camelize);
+            }
+        }
+        // no results...
+        return;
+    }
+    const params = keys.map(prop => {
+        return t.objectProperty(camelize ? t.identifier(camel(prop)) : t.identifier(prop), camelize ? t.identifier(camel(prop)) : t.identifier(prop), false, true);
+    });
+    const obj = t.objectPattern([
+        ...params
+    ]);
+    obj.typeAnnotation = getParamsTypeAnnotation(context, jsonschema, camelize);
+    return obj;
+};

package/{types/index.d.ts → index.d.ts}

@@ -4,6 +4,5 @@ export * from './context';
 export * from './recoil';
 export * from './message-composer';
 export * from './react-query';
-export * from './types';
 export * from './message-builder';
 export * from './provider';

package/index.js

@@ -0,0 +1,24 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./utils"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./recoil"), exports);
+__exportStar(require("./message-composer"), exports);
+__exportStar(require("./react-query"), exports);
+__exportStar(require("./message-builder"), exports);
+__exportStar(require("./provider"), exports);

package/message-builder/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./message-builder"), exports);

package/{types/message-builder → message-builder}/message-builder.d.ts

@@ -1,4 +1,4 @@
 import * as t from '@babel/types';
-import { ExecuteMsg, QueryMsg } from '../types';
+import { ExecuteMsg, QueryMsg } from '@cosmology/ts-codegen-types';
 import { RenderContext } from '../context';
 export declare const createMessageBuilderClass: (context: RenderContext, className: string, msg: ExecuteMsg | QueryMsg) => t.ExportNamedDeclaration;