wasm-ast-types 0.26.4 → 1.1.0

package/context/context.js

@@ -0,0 +1,114 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RenderContext = exports.RenderContextBase = exports.BuilderContext = exports.getDefinitionSchema = exports.defaultOptions = void 0;
+const utils_1 = require("../utils");
+const imports_1 = require("./imports");
+const deepmerge_1 = __importDefault(require("deepmerge"));
+const path_1 = require("path");
+;
+exports.defaultOptions = {
+    enabled: true,
+    types: {
+        enabled: true,
+        itemsUseTuples: false,
+        aliasExecuteMsg: false
+    },
+    client: {
+        enabled: true,
+        execExtendsQuery: true,
+        noImplicitOverride: false,
+    },
+    recoil: {
+        enabled: false
+    },
+    messageComposer: {
+        enabled: false
+    },
+    messageBuilder: {
+        enabled: false,
+    },
+    reactQuery: {
+        enabled: false,
+        optionalClient: false,
+        version: 'v4',
+        mutations: false,
+        camelize: true,
+        queryKeys: false
+    }
+};
+const getDefinitionSchema = (schemas) => {
+    const aggregateSchema = {
+        definitions: {
+        //
+        }
+    };
+    schemas.forEach(schema => {
+        schema.definitions = schema.definitions || {};
+        aggregateSchema.definitions = {
+            ...aggregateSchema.definitions,
+            ...schema.definitions
+        };
+    });
+    return aggregateSchema;
+};
+exports.getDefinitionSchema = getDefinitionSchema;
+class BuilderContext {
+    providers = {};
+    addProviderInfo(contractName, type, classname, filename) {
+        if (!this.providers[contractName]) {
+            this.providers[contractName] = {};
+        }
+        this.providers[contractName][type] = {
+            classname,
+            filename,
+            basename: (0, path_1.basename)(filename, (0, path_1.extname)(filename))
+        };
+    }
+    getProviderInfos() {
+        return this.providers;
+    }
+}
+exports.BuilderContext = BuilderContext;
+/**
+ * context object for generating code.
+ * only mergeDefaultOpt needs to implementing for combine options and default options.
+ * @param TOpt option type
+ */
+class RenderContextBase {
+    builderContext;
+    contract;
+    utils = {};
+    schema;
+    options;
+    constructor(contract, options, builderContext) {
+        this.contract = contract;
+        this.schema = (0, exports.getDefinitionSchema)(contract.schemas);
+        this.options = this.mergeDefaultOpt(options);
+        this.builderContext = builderContext;
+    }
+    refLookup($ref) {
+        return (0, utils_1.refLookup)($ref, this.schema);
+    }
+    addUtil(util) {
+        this.utils[util] = true;
+    }
+    addProviderInfo(contractName, type, classname, filename) {
+        this.builderContext.addProviderInfo(contractName, type, classname, filename);
+    }
+    getProviderInfos() {
+        return this.builderContext.providers;
+    }
+    getImports(registeredUtils, filepath) {
+        return (0, imports_1.getImportStatements)((0, imports_1.convertUtilsToImportList)(this, Object.keys(this.utils), registeredUtils), filepath);
+    }
+}
+exports.RenderContextBase = RenderContextBase;
+class RenderContext extends RenderContextBase {
+    mergeDefaultOpt(options) {
+        return (0, deepmerge_1.default)(exports.defaultOptions, options ?? {});
+    }
+}
+exports.RenderContext = RenderContext;

package/{types/context → context}/imports.d.ts

@@ -1,3 +1,4 @@
+import * as t from '@babel/types';
 import { RenderContext } from './context';
 export interface ImportObj {
     type: 'import' | 'default' | 'namespace';
@@ -5,8 +6,8 @@ export interface ImportObj {
     path: string;
     importAs?: string;
 }
-export declare type GetUtilFn = (<TContext = RenderContext>(...args: any[]) => (context: TContext) => ImportObj);
-export declare type UtilMapping = {
+export type GetUtilFn = (<TContext = RenderContext>(...args: any[]) => (context: TContext) => ImportObj);
+export type UtilMapping = {
     [key: string]: ImportObj | string | GetUtilFn;
 };
 export declare const UTILS: {
@@ -22,26 +23,26 @@ export declare const UTILS: {
     useQuery: (context: RenderContext) => {
         type: string;
         path: string;
-        name: any;
+        name: string;
     };
     UseQueryOptions: (context: RenderContext) => {
         type: string;
         path: string;
-        name: any;
+        name: string;
     };
     useMutation: (context: RenderContext) => {
         type: string;
         path: string;
-        name: any;
+        name: string;
     };
     UseMutationOptions: (context: RenderContext) => {
         type: string;
         path: string;
-        name: any;
+        name: string;
     };
 };
 export declare const UTIL_HELPERS: string[];
 export declare const convertUtilsToImportList: (context: RenderContext, utils: string[], registeredUtils?: UtilMapping) => ImportObj[];
-export declare const convertUtil: (context: RenderContext, util: string, registeredUtils: object) => ImportObj;
-export declare const getImportStatements: (list: ImportObj[], filepath?: string) => any[];
+export declare const convertUtil: (context: RenderContext, util: string, registeredUtils: any) => ImportObj;
+export declare const getImportStatements: (list: ImportObj[], filepath?: string) => (t.ImportNamespaceSpecifier | t.ImportDeclaration | t.ImportDefaultSpecifier)[];
 export declare const getRelativePath: (f1: string, f2: string) => string;

package/context/imports.js

@@ -0,0 +1,166 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelativePath = exports.getImportStatements = exports.convertUtil = exports.convertUtilsToImportList = exports.UTIL_HELPERS = exports.UTILS = void 0;
+const t = __importStar(require("@babel/types"));
+const utils_1 = require("../utils");
+const path_1 = require("path");
+const makeReactQuerySwitch = (varName) => {
+    return (context) => {
+        switch (context.options.reactQuery.version) {
+            case 'v4':
+                return {
+                    type: 'import',
+                    path: '@tanstack/react-query',
+                    name: varName
+                };
+            case 'v3':
+            default:
+                return {
+                    type: 'import',
+                    path: 'react-query',
+                    name: varName
+                };
+        }
+    };
+};
+exports.UTILS = {
+    selectorFamily: 'recoil',
+    MsgExecuteContract: 'cosmjs-types/cosmwasm/wasm/v1/tx',
+    MsgExecuteContractEncodeObject: '@cosmjs/cosmwasm-stargate',
+    Coin: '@cosmjs/amino',
+    toUtf8: '@cosmjs/encoding',
+    StdFee: '@cosmjs/amino',
+    CosmWasmClient: '@cosmjs/cosmwasm-stargate',
+    ExecuteResult: '@cosmjs/cosmwasm-stargate',
+    SigningCosmWasmClient: '@cosmjs/cosmwasm-stargate',
+    // react-query
+    useQuery: makeReactQuerySwitch('useQuery'),
+    UseQueryOptions: makeReactQuerySwitch('UseQueryOptions'),
+    useMutation: makeReactQuerySwitch('useMutation'),
+    UseMutationOptions: makeReactQuerySwitch('UseMutationOptions')
+};
+exports.UTIL_HELPERS = [
+    '__contractContextBase__',
+];
+const convertUtilsToImportList = (context, utils, registeredUtils) => {
+    return utils.map((util) => {
+        let result = null;
+        if (registeredUtils) {
+            result = (0, exports.convertUtil)(context, util, registeredUtils);
+            if (result) {
+                return result;
+            }
+        }
+        result = (0, exports.convertUtil)(context, util, exports.UTILS);
+        if (result) {
+            return result;
+        }
+        throw new Error(`missing Util! ::[${util}]`);
+    });
+};
+exports.convertUtilsToImportList = convertUtilsToImportList;
+const convertUtil = (context, util, registeredUtils) => {
+    if (!registeredUtils.hasOwnProperty(util))
+        return null;
+    if (typeof registeredUtils[util] === 'string') {
+        return {
+            type: 'import',
+            path: registeredUtils[util],
+            name: util
+        };
+    }
+    else if (typeof registeredUtils[util] === 'function') {
+        return registeredUtils[util](context);
+    }
+    else {
+        return registeredUtils[util];
+    }
+};
+exports.convertUtil = convertUtil;
+// __helpers__
+const getImportStatements = (list, filepath) => {
+    // swap helpers with helpers file...
+    const modifiedImports = list.map(imp => {
+        if (filepath && exports.UTIL_HELPERS.includes(imp.path)) {
+            const name = imp.path.replace(/__/g, '');
+            return {
+                ...imp,
+                path: (0, exports.getRelativePath)(filepath, `./${name}`)
+            };
+        }
+        return imp;
+    });
+    const imports = modifiedImports.reduce((m, obj) => {
+        m[obj.path] = m[obj.path] || [];
+        const exists = m[obj.path].find((el) => el.type === obj.type && el.path === obj.path && el.name === obj.name);
+        // MARKED AS NOT DRY [google.protobuf names]
+        // TODO some have google.protobuf.Any shows up... figure out the better way to handle this
+        if (/\./.test(obj.name)) {
+            obj.name = obj.name.split('.')[obj.name.split('.').length - 1];
+        }
+        if (!exists) {
+            m[obj.path].push(obj);
+        }
+        return m;
+    }, {});
+    return Object.entries(imports)
+        .reduce((m, [importPath, imports]) => {
+        const defaultImports = imports.filter(a => a.type === 'default');
+        if (defaultImports.length) {
+            if (defaultImports.length > 1)
+                throw new Error('more than one default name NOT allowed.');
+            m.push(t.importDeclaration([
+                t.importDefaultSpecifier(t.identifier(defaultImports[0].name))
+            ], t.stringLiteral(defaultImports[0].path)));
+        }
+        const namedImports = imports.filter(a => a.type === 'import' && (!a.importAs || (a.name === a.importAs)));
+        if (namedImports.length) {
+            m.push((0, utils_1.importStmt)(namedImports.map(i => i.name), namedImports[0].path));
+        }
+        const aliasNamedImports = imports.filter(a => a.type === 'import' && (a.importAs && (a.name !== a.importAs)));
+        aliasNamedImports.forEach(imp => {
+            m.push((0, utils_1.importAs)(imp.name, imp.importAs, imp.path));
+        });
+        const namespaced = imports.filter(a => a.type === 'namespace');
+        if (namespaced.length) {
+            if (namespaced.length > 1)
+                throw new Error('more than one namespaced name NOT allowed.');
+            m.push(t.importDeclaration([
+                t.importNamespaceSpecifier(t.identifier(namespaced[0].name))
+            ], t.stringLiteral(namespaced[0].path)));
+        }
+        return m;
+    }, []);
+};
+exports.getImportStatements = getImportStatements;
+const getRelativePath = (f1, f2) => {
+    const rel = (0, path_1.relative)((0, path_1.dirname)(f1), f2);
+    let importPath = rel.replace((0, path_1.extname)(rel), '');
+    if (!/^\./.test(importPath))
+        importPath = `./${importPath}`;
+    return importPath;
+};
+exports.getRelativePath = getRelativePath;

package/context/index.js

@@ -0,0 +1,18 @@
+"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("./context"), exports);
+__exportStar(require("./imports"), exports);

package/esm/client/client.js

@@ -0,0 +1,238 @@
+import * as t from '@babel/types';
+import { camel } from 'case';
+import { arrowFunctionExpression, bindMethod, classDeclaration, classProperty, FIXED_EXECUTE_PARAMS, getMessageProperties, OPTIONAL_FUNDS_PARAM, promiseTypeAnnotation, typedIdentifier, getTypeOrRef } from '../utils';
+import { createTypedObjectParams, getPropertyType, getResponseType } from '../utils/types';
+import { identifier, propertySignature } from '../utils/babel';
+export const CONSTANT_EXEC_PARAMS = [
+    t.assignmentPattern(identifier('fee', t.tsTypeAnnotation(t.tsUnionType([
+        t.tSNumberKeyword(),
+        t.tsTypeReference(t.identifier('StdFee')),
+        t.tsLiteralType(t.stringLiteral('auto'))
+    ])), false), t.stringLiteral('auto')),
+    identifier('memo', t.tsTypeAnnotation(t.tsStringKeyword()), true),
+    OPTIONAL_FUNDS_PARAM
+];
+export const createWasmQueryMethod = (context, jsonschema) => {
+    const underscoreName = Object.keys(jsonschema.properties)[0];
+    const methodName = camel(underscoreName);
+    const responseType = getResponseType(context, underscoreName);
+    const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+    const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
+    const msgAction = t.identifier(underscoreName);
+    // If the param is an identifier, we can just use it as is
+    const msgActionValue = param?.type === 'Identifier'
+        ? t.identifier(param.name)
+        : t.objectExpression(args);
+    return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param ? [param] : [], 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([t.objectProperty(msgAction, msgActionValue)])
+        ]))
+    ]), t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([
+        t.tSTypeReference(t.identifier(responseType))
+    ]))), true));
+};
+export const createQueryClass = (context, className, implementsClassName, queryMsg) => {
+    context.addUtil('CosmWasmClient');
+    const propertyNames = getMessageProperties(queryMsg)
+        .map((method) => Object.keys(method.properties)?.[0])
+        .filter(Boolean);
+    const bindings = propertyNames.map(camel).map(bindMethod);
+    const methods = getMessageProperties(queryMsg).map((schema) => {
+        return createWasmQueryMethod(context, 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 getWasmMethodArgs = (context, jsonschema) => {
+    let keys = Object.keys(jsonschema.properties ?? {});
+    // only 1 degree $ref-lookup
+    if (!keys.length && jsonschema.$ref) {
+        const obj = context.refLookup(jsonschema.$ref);
+        // properties
+        if (obj) {
+            keys = Object.keys(obj.properties ?? {});
+        }
+        // tuple struct or otherwise, use the name of the reference
+        if (!keys.length && obj?.oneOf) {
+            // TODO????? ADAIR
+        }
+    }
+    const args = keys.map((prop) => {
+        return t.objectProperty(t.identifier(prop), t.identifier(camel(prop)), false, prop === camel(prop));
+    });
+    return args;
+};
+export const createWasmExecMethod = (context, jsonschema) => {
+    context.addUtil('ExecuteResult');
+    context.addUtil('StdFee');
+    context.addUtil('Coin');
+    const underscoreName = Object.keys(jsonschema.properties)[0];
+    const methodName = camel(underscoreName);
+    const param = createTypedObjectParams(context, jsonschema.properties[underscoreName]);
+    const args = getWasmMethodArgs(context, jsonschema.properties[underscoreName]);
+    const msgAction = t.identifier(underscoreName);
+    // If the param is an identifier, we can just use it as is
+    const msgActionValue = param?.type === 'Identifier'
+        ? t.identifier(param.name)
+        : t.objectExpression(args);
+    return t.classProperty(t.identifier(methodName), arrowFunctionExpression(param
+        ? [
+            // props
+            param,
+            ...CONSTANT_EXEC_PARAMS
+        ]
+        : CONSTANT_EXEC_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(msgAction, msgActionValue)
+            ]),
+            t.identifier('fee'),
+            t.identifier('memo'),
+            t.identifier('_funds')
+        ])))
+    ]), 
+    // return type
+    t.tsTypeAnnotation(t.tsTypeReference(t.identifier('Promise'), t.tsTypeParameterInstantiation([
+        t.tSTypeReference(t.identifier('ExecuteResult'))
+    ]))), true));
+};
+export const createExecuteClass = (context, className, implementsClassName, extendsClassName, execMsg) => {
+    context.addUtil('SigningCosmWasmClient');
+    const propertyNames = getMessageProperties(execMsg)
+        .map((method) => Object.keys(method.properties)?.[0])
+        .filter(Boolean);
+    const bindings = propertyNames.map(camel).map(bindMethod);
+    const methods = getMessageProperties(execMsg).map((schema) => {
+        return createWasmExecMethod(context, schema);
+    });
+    const blockStmt = [];
+    if (extendsClassName) {
+        blockStmt.push(
+        // super()
+        t.expressionStatement(t.callExpression(t.super(), [
+            t.identifier('client'),
+            t.identifier('contractAddress')
+        ])));
+    }
+    blockStmt.push(...[
+        // 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('sender')), t.identifier('sender'))),
+        t.expressionStatement(t.assignmentExpression('=', t.memberExpression(t.thisExpression(), t.identifier('contractAddress')), t.identifier('contractAddress'))),
+        ...bindings
+    ]);
+    const noImplicitOverride = context.options.client.noImplicitOverride &&
+        extendsClassName &&
+        context.options.client.execExtendsQuery;
+    return t.exportNamedDeclaration(classDeclaration(className, [
+        // client
+        classProperty('client', t.tsTypeAnnotation(t.tsTypeReference(t.identifier('SigningCosmWasmClient'))), false, false, noImplicitOverride),
+        // sender
+        classProperty('sender', t.tsTypeAnnotation(t.tsStringKeyword())),
+        // contractAddress
+        classProperty('contractAddress', t.tsTypeAnnotation(t.tsStringKeyword()), false, false, noImplicitOverride),
+        // 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(blockStmt)),
+        ...methods
+    ], [t.tSExpressionWithTypeArguments(t.identifier(implementsClassName))], extendsClassName ? t.identifier(extendsClassName) : null));
+};
+export const createExecuteInterface = (context, className, extendsClassName, execMsg) => {
+    const methods = getMessageProperties(execMsg).map((jsonschema) => {
+        const underscoreName = Object.keys(jsonschema.properties)[0];
+        const methodName = camel(underscoreName);
+        return createPropertyFunctionWithObjectParamsForExec(context, methodName, 'ExecuteResult', jsonschema.properties[underscoreName]);
+    });
+    const extendsAst = extendsClassName
+        ? [t.tSExpressionWithTypeArguments(t.identifier(extendsClassName))]
+        : [];
+    return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(className), null, extendsAst, 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 createPropertyFunctionWithObjectParams = (context, methodName, responseType, jsonschema) => {
+    const obj = createTypedObjectParams(context, jsonschema);
+    const func = {
+        type: 'TSFunctionType',
+        typeAnnotation: promiseTypeAnnotation(responseType),
+        parameters: obj ? [obj] : []
+    };
+    return t.tSPropertySignature(t.identifier(methodName), t.tsTypeAnnotation(
+    // @ts-ignore:next-line
+    func));
+};
+export const createPropertyFunctionWithObjectParamsForExec = (context, methodName, responseType, jsonschema) => {
+    context.addUtil('Coin');
+    const obj = createTypedObjectParams(context, jsonschema);
+    const func = {
+        type: 'TSFunctionType',
+        typeAnnotation: promiseTypeAnnotation(responseType),
+        parameters: obj ? [obj, ...FIXED_EXECUTE_PARAMS] : FIXED_EXECUTE_PARAMS
+    };
+    return t.tSPropertySignature(t.identifier(methodName), t.tsTypeAnnotation(
+    // @ts-ignore:next-line
+    func));
+};
+export const createQueryInterface = (context, className, queryMsg) => {
+    const methods = getMessageProperties(queryMsg).map((jsonschema) => {
+        const underscoreName = Object.keys(jsonschema.properties)[0];
+        const methodName = camel(underscoreName);
+        const responseType = getResponseType(context, underscoreName);
+        return createPropertyFunctionWithObjectParams(context, methodName, responseType, jsonschema.properties[underscoreName]);
+    });
+    return t.exportNamedDeclaration(t.tsInterfaceDeclaration(t.identifier(className), null, [], t.tSInterfaceBody([
+        t.tSPropertySignature(t.identifier('contractAddress'), t.tsTypeAnnotation(t.tsStringKeyword())),
+        ...methods
+    ])));
+};
+export const createTypeOrInterface = (context, Type, jsonschema) => {
+    // Handle non-object and potentially union or referenced types
+    if (jsonschema.type !== 'object') {
+        if (!jsonschema.type) {
+            if (jsonschema.title) {
+                return t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(Type), null, t.tsTypeReference(t.identifier(jsonschema.title))));
+            }
+            else {
+                throw new Error('Schema must have a type or title!');
+            }
+        }
+        // Use getTypeOrRef to handle string, array of strings, or $ref
+        const typeAnnotation = getTypeOrRef(jsonschema);
+        return t.exportNamedDeclaration(t.tsTypeAliasDeclaration(t.identifier(Type), null, typeAnnotation));
+    }
+    // Handle object type schemas
+    const props = Object.keys(jsonschema.properties ?? {}).map((prop) => {
+        const { type, optional } = getPropertyType(context, 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 = (context, jsonschema) => {
+    const Type = jsonschema.title;
+    return createTypeOrInterface(context, Type, jsonschema);
+};

package/esm/client/index.js

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