diff --git a/src/commands/contract/helpers.ts b/src/commands/contract/helpers.ts
index 705e1a4..3e25bf6 100644
--- a/src/commands/contract/helpers.ts
+++ b/src/commands/contract/helpers.ts
@@ -211,6 +211,21 @@ function findAliasType(typeString: string, abi: ABI.Def): string | undefined {
     return alias?.type && `${alias?.type}${decorator || ''}`
 }
 
+export function findAbiStruct(
+    type: string,
+    abi: ABI.Def,
+): ABI.Struct | undefined {
+    const extractDecoratorResponse = extractDecorator(type)
+    const typeString = extractDecoratorResponse.type
+    const decorator = extractDecoratorResponse.decorator
+
+    const abiStruct = abi.structs.find(
+        (abiType) => abiType.name === typeString
+    )
+
+    return abiStruct
+}
+
 export function findAbiType(
     type: string,
     abi: ABI.Def,
@@ -299,3 +314,17 @@ export function capitalize(string) {
 
     return string.charAt(0).toUpperCase() + string.slice(1)
 }
+
+export function removeDuplicateInterfaces(interfaces: ts.InterfaceDeclaration[]): ts.InterfaceDeclaration[] {
+    const seen: string[] = [];
+
+    return interfaces.filter(interfaceDeclaration => {
+        const name = String(interfaceDeclaration.name.escapedText);
+
+        if (seen.includes(name)) {
+            return false;
+        }
+        seen.push(name);
+        return true;
+    });
+}
diff --git a/src/commands/contract/interfaces.ts b/src/commands/contract/interfaces.ts
index a8b4bab..eb29344 100644
--- a/src/commands/contract/interfaces.ts
+++ b/src/commands/contract/interfaces.ts
@@ -1,8 +1,7 @@
 import type {ABI} from '@wharfkit/antelope'
 import ts from 'typescript'
-import {findExternalType, parseType} from './helpers'
+import {findAbiStruct, findExternalType, parseType, removeDuplicateInterfaces} from './helpers'
 import {getActionFieldFromAbi} from './structs'
-import {capitalizeName} from '../../utils'
 
 export function generateActionNamesInterface(abi: ABI.Def): ts.InterfaceDeclaration {
     // Generate property signatures for each action
@@ -10,13 +9,11 @@ export function generateActionNamesInterface(abi: ABI.Def): ts.InterfaceDeclarat
         const actionName = String(action.name)
         const actionNameKey = actionName.includes('.') ? `'${actionName}'` : actionName
 
-        const actionNameCapitalized = capitalizeName(actionName)
-
         return ts.factory.createPropertySignature(
             undefined,
             actionNameKey,
             undefined,
-            ts.factory.createTypeReferenceNode(`ActionParams.${actionNameCapitalized}`)
+            ts.factory.createTypeReferenceNode(`ActionParams.${actionName}`)
         )
     })
 
@@ -29,12 +26,29 @@ export function generateActionNamesInterface(abi: ABI.Def): ts.InterfaceDeclarat
     )
 }
 
-export function generateActionInterface(actionStruct, abi): ts.InterfaceDeclaration {
-    const members = actionStruct.fields.map((field) => {
+export function generateActionInterface(struct, abi): { actionInterface: ts.InterfaceDeclaration, typeInterfaces: ts.InterfaceDeclaration[] } {
+    const typeInterfaces: ts.InterfaceDeclaration[] = []
+
+    const members = struct.fields.map((field) => {
         const typeReferenceNode = ts.factory.createTypeReferenceNode(
             findParamTypeString(field.type, 'Types.', abi)
         )
 
+        // We need to check for types and variants. We also need to add core types that may be used in structs that are
+        // used in action params (the check will have to recursivly look for those structs). Optionally, we can add all
+        // core types and have eslint remove them.
+        if (field.type === 'blockchain_parameters_v1') {
+            console.log({type: field.type})
+        }
+
+        const typeStruct = findAbiStruct(field.type, abi)
+
+        if (typeStruct) {
+            const interfaces = generateActionInterface(typeStruct, abi)
+            
+            typeInterfaces.push(interfaces.actionInterface, ...interfaces.typeInterfaces)
+        }
+
         return ts.factory.createPropertySignature(
             undefined,
             field.name.toLowerCase(),
@@ -43,29 +57,49 @@ export function generateActionInterface(actionStruct, abi): ts.InterfaceDeclarat
         )
     })
 
-    return ts.factory.createInterfaceDeclaration(
+    const actionInterface = ts.factory.createInterfaceDeclaration(
         [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
-        capitalizeName(actionStruct.structName),
+        struct.structName || struct.name,
         undefined,
         undefined,
         members
     )
+
+    return { actionInterface, typeInterfaces: removeDuplicateInterfaces(typeInterfaces) }
 }
 
 export function generateActionsNamespace(abi: ABI.Def): ts.ModuleDeclaration {
     const actionStructsWithFields = getActionFieldFromAbi(abi)
 
+    const typeInterfaces: ts.InterfaceDeclaration[] = []
+
     const interfaces = abi.actions.map((action) => {
         const actionStruct = actionStructsWithFields.find(
             (actionStructWithField) => actionStructWithField.structName === action.type
         )
-        return generateActionInterface(actionStruct, abi)
+
+        const interfaces = generateActionInterface(actionStruct, abi)
+
+        if (interfaces.actionInterface) {
+            typeInterfaces.push(...interfaces.typeInterfaces)
+        }
+            
+        return interfaces.actionInterface
     })
 
+    const actionParamsTypes = ts.factory.createModuleDeclaration(
+        [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+        ts.factory.createIdentifier('Types'),
+        ts.factory.createModuleBlock(
+            removeDuplicateInterfaces(typeInterfaces)
+        ),
+        ts.NodeFlags.Namespace
+    )
+
     return ts.factory.createModuleDeclaration(
         [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
         ts.factory.createIdentifier('ActionParams'),
-        ts.factory.createModuleBlock(interfaces),
+        ts.factory.createModuleBlock([actionParamsTypes, ...interfaces]),
         ts.NodeFlags.Namespace
     )
 }
diff --git a/test/tmp/eosio.ts b/test/tmp/eosio.ts
new file mode 100644
index 0000000..4a98675
--- /dev/null
+++ b/test/tmp/eosio.ts
@@ -0,0 +1,1544 @@
+import type {
+    Action,
+    AssetType,
+    BytesType,
+    Checksum256Type,
+    Int64Type,
+    NameType,
+    PublicKeyType,
+    UInt128Type,
+    UInt16Type,
+    UInt32Type,
+    UInt64Type,
+    UInt8Type,
+    VarUIntType,
+} from '@wharfkit/antelope'
+import {
+    ABI,
+    Asset,
+    Blob,
+    BlockTimestamp,
+    Bytes,
+    Checksum256,
+    Float64,
+    Int64,
+    Name,
+    PublicKey,
+    Struct,
+    TimePoint,
+    TimePointSec,
+    UInt128,
+    UInt16,
+    UInt32,
+    UInt64,
+    UInt8,
+    Variant,
+    VarUInt,
+} from '@wharfkit/antelope'
+import type {ActionOptions, ContractArgs, PartialBy, Table} from '@wharfkit/contract'
+import {Contract as BaseContract} from '@wharfkit/contract'
+export const abiBlob = Blob.from(
+    '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'
+)
+export const abi = ABI.from(abiBlob)
+export class Contract extends BaseContract {
+    constructor(args: PartialBy<ContractArgs, 'abi' | 'account'>) {
+        super({
+            client: args.client,
+            abi: abi,
+            account: args.account || Name.from('eosio'),
+        })
+    }
+    action<T extends ActionNames>(
+        name: T,
+        data: ActionNameParams[T],
+        options?: ActionOptions
+    ): Action {
+        return super.action(name, data, options)
+    }
+    table<T extends TableNames>(name: T, scope?: NameType): Table<RowType<T>> {
+        return super.table(name, scope, TableMap[name])
+    }
+}
+export interface ActionNameParams {
+    activate: ActionParams.activate
+    bidname: ActionParams.bidname
+    bidrefund: ActionParams.bidrefund
+    buyram: ActionParams.buyram
+    buyrambytes: ActionParams.buyrambytes
+    buyrex: ActionParams.buyrex
+    canceldelay: ActionParams.canceldelay
+    cfgpowerup: ActionParams.cfgpowerup
+    claimrewards: ActionParams.claimrewards
+    closerex: ActionParams.closerex
+    cnclrexorder: ActionParams.cnclrexorder
+    consolidate: ActionParams.consolidate
+    defcpuloan: ActionParams.defcpuloan
+    defnetloan: ActionParams.defnetloan
+    delegatebw: ActionParams.delegatebw
+    deleteauth: ActionParams.deleteauth
+    deposit: ActionParams.deposit
+    fundcpuloan: ActionParams.fundcpuloan
+    fundnetloan: ActionParams.fundnetloan
+    init: ActionParams.init
+    limitauthchg: ActionParams.limitauthchg
+    linkauth: ActionParams.linkauth
+    mvfrsavings: ActionParams.mvfrsavings
+    mvtosavings: ActionParams.mvtosavings
+    newaccount: ActionParams.newaccount
+    onblock: ActionParams.onblock
+    onerror: ActionParams.onerror
+    powerup: ActionParams.powerup
+    powerupexec: ActionParams.powerupexec
+    refund: ActionParams.refund
+    regproducer: ActionParams.regproducer
+    regproducer2: ActionParams.regproducer2
+    regproxy: ActionParams.regproxy
+    rentcpu: ActionParams.rentcpu
+    rentnet: ActionParams.rentnet
+    rexexec: ActionParams.rexexec
+    rmvproducer: ActionParams.rmvproducer
+    sellram: ActionParams.sellram
+    sellrex: ActionParams.sellrex
+    setabi: ActionParams.setabi
+    setacctcpu: ActionParams.setacctcpu
+    setacctnet: ActionParams.setacctnet
+    setacctram: ActionParams.setacctram
+    setalimits: ActionParams.setalimits
+    setcode: ActionParams.setcode
+    setinflation: ActionParams.setinflation
+    setparams: ActionParams.setparams
+    setpriv: ActionParams.setpriv
+    setram: ActionParams.setram
+    setramrate: ActionParams.setramrate
+    setrex: ActionParams.setrex
+    undelegatebw: ActionParams.undelegatebw
+    unlinkauth: ActionParams.unlinkauth
+    unregprod: ActionParams.unregprod
+    unstaketorex: ActionParams.unstaketorex
+    updateauth: ActionParams.updateauth
+    updaterex: ActionParams.updaterex
+    updtrevision: ActionParams.updtrevision
+    voteproducer: ActionParams.voteproducer
+    voteupdate: ActionParams.voteupdate
+    wasmcfg: ActionParams.wasmcfg
+    withdraw: ActionParams.withdraw
+}
+export namespace ActionParams {
+    export namespace Types {
+        export interface permission_level {
+            actor: NameType
+            permission: NameType
+        }
+        export interface powerup_config {
+            net: Types.powerup_config_resource
+            cpu: Types.powerup_config_resource
+            powerup_days: UInt32Type
+            min_powerup_fee: AssetType
+        }
+        export interface powerup_config_resource {
+            current_weight_ratio: Int64Type
+            target_weight_ratio: Int64Type
+            assumed_stake_weight: Int64Type
+            target_timestamp: TimePointSecType
+            exponent: Float64Type
+            decay_secs: UInt32Type
+            min_price: AssetType
+            max_price: AssetType
+        }
+        export interface authority {
+            threshold: UInt32Type
+            keys: Types.key_weight[]
+            accounts: Types.permission_level_weight[]
+            waits: Types.wait_weight[]
+        }
+        export interface key_weight {
+            key: PublicKeyType
+            weight: UInt16Type
+        }
+        export interface permission_level_weight {
+            permission: Types.permission_level
+            weight: UInt16Type
+        }
+        export interface wait_weight {
+            wait_sec: UInt32Type
+            weight: UInt16Type
+        }
+        export interface block_header {
+            timestamp: UInt32Type
+            producer: NameType
+            confirmed: UInt16Type
+            previous: Checksum256Type
+            transaction_mroot: Checksum256Type
+            action_mroot: Checksum256Type
+            schedule_version: UInt32Type
+            new_producers: Types.producer_schedule
+        }
+        export interface producer_schedule {
+            version: UInt32Type
+            producers: Types.producer_key[]
+        }
+        export interface producer_key {
+            producer_name: NameType
+            block_signing_key: PublicKeyType
+        }
+    }
+    export interface activate {
+        feature_digest: Checksum256Type
+    }
+    export interface bidname {
+        bidder: NameType
+        newname: NameType
+        bid: AssetType
+    }
+    export interface bidrefund {
+        bidder: NameType
+        newname: NameType
+    }
+    export interface buyram {
+        payer: NameType
+        receiver: NameType
+        quant: AssetType
+    }
+    export interface buyrambytes {
+        payer: NameType
+        receiver: NameType
+        bytes: UInt32Type
+    }
+    export interface buyrex {
+        from: NameType
+        amount: AssetType
+    }
+    export interface canceldelay {
+        canceling_auth: Types.permission_level
+        trx_id: Checksum256Type
+    }
+    export interface cfgpowerup {
+        args: Types.powerup_config
+    }
+    export interface claimrewards {
+        owner: NameType
+    }
+    export interface closerex {
+        owner: NameType
+    }
+    export interface cnclrexorder {
+        owner: NameType
+    }
+    export interface consolidate {
+        owner: NameType
+    }
+    export interface defcpuloan {
+        from: NameType
+        loan_num: UInt64Type
+        amount: AssetType
+    }
+    export interface defnetloan {
+        from: NameType
+        loan_num: UInt64Type
+        amount: AssetType
+    }
+    export interface delegatebw {
+        from: NameType
+        receiver: NameType
+        stake_net_quantity: AssetType
+        stake_cpu_quantity: AssetType
+        transfer: boolean
+    }
+    export interface deleteauth {
+        account: NameType
+        permission: NameType
+        authorized_by?: NameType
+    }
+    export interface deposit {
+        owner: NameType
+        amount: AssetType
+    }
+    export interface fundcpuloan {
+        from: NameType
+        loan_num: UInt64Type
+        payment: AssetType
+    }
+    export interface fundnetloan {
+        from: NameType
+        loan_num: UInt64Type
+        payment: AssetType
+    }
+    export interface init {
+        version: VarUIntType
+        core: Asset.SymbolType
+    }
+    export interface limitauthchg {
+        account: NameType
+        allow_perms: NameType[]
+        disallow_perms: NameType[]
+    }
+    export interface linkauth {
+        account: NameType
+        code: NameType
+        type: NameType
+        requirement: NameType
+        authorized_by?: NameType
+    }
+    export interface mvfrsavings {
+        owner: NameType
+        rex: AssetType
+    }
+    export interface mvtosavings {
+        owner: NameType
+        rex: AssetType
+    }
+    export interface newaccount {
+        creator: NameType
+        name: NameType
+        owner: Types.authority
+        active: Types.authority
+    }
+    export interface onblock {
+        header: Types.block_header
+    }
+    export interface onerror {
+        sender_id: UInt128Type
+        sent_trx: BytesType
+    }
+    export interface powerup {
+        payer: NameType
+        receiver: NameType
+        days: UInt32Type
+        net_frac: Int64Type
+        cpu_frac: Int64Type
+        max_payment: AssetType
+    }
+    export interface powerupexec {
+        user: NameType
+        max: UInt16Type
+    }
+    export interface refund {
+        owner: NameType
+    }
+    export interface regproducer {
+        producer: NameType
+        producer_key: PublicKeyType
+        url: string
+        location: UInt16Type
+    }
+    export interface regproducer2 {
+        producer: NameType
+        producer_authority: Types.variant_block_signing_authority_v0
+        url: string
+        location: UInt16Type
+    }
+    export interface regproxy {
+        proxy: NameType
+        isproxy: boolean
+    }
+    export interface rentcpu {
+        from: NameType
+        receiver: NameType
+        loan_payment: AssetType
+        loan_fund: AssetType
+    }
+    export interface rentnet {
+        from: NameType
+        receiver: NameType
+        loan_payment: AssetType
+        loan_fund: AssetType
+    }
+    export interface rexexec {
+        user: NameType
+        max: UInt16Type
+    }
+    export interface rmvproducer {
+        producer: NameType
+    }
+    export interface sellram {
+        account: NameType
+        bytes: Int64Type
+    }
+    export interface sellrex {
+        from: NameType
+        rex: AssetType
+    }
+    export interface setabi {
+        account: NameType
+        abi: BytesType
+        memo?: string
+    }
+    export interface setacctcpu {
+        account: NameType
+        cpu_weight?: Int64Type
+    }
+    export interface setacctnet {
+        account: NameType
+        net_weight?: Int64Type
+    }
+    export interface setacctram {
+        account: NameType
+        ram_bytes?: Int64Type
+    }
+    export interface setalimits {
+        account: NameType
+        ram_bytes: Int64Type
+        net_weight: Int64Type
+        cpu_weight: Int64Type
+    }
+    export interface setcode {
+        account: NameType
+        vmtype: UInt8Type
+        vmversion: UInt8Type
+        code: BytesType
+        memo?: string
+    }
+    export interface setinflation {
+        annual_rate: Int64Type
+        inflation_pay_factor: Int64Type
+        votepay_factor: Int64Type
+    }
+    export interface setparams {
+        params: Types.blockchain_parameters_v1
+    }
+    export interface setpriv {
+        account: NameType
+        is_priv: UInt8Type
+    }
+    export interface setram {
+        max_ram_size: UInt64Type
+    }
+    export interface setramrate {
+        bytes_per_block: UInt16Type
+    }
+    export interface setrex {
+        balance: AssetType
+    }
+    export interface undelegatebw {
+        from: NameType
+        receiver: NameType
+        unstake_net_quantity: AssetType
+        unstake_cpu_quantity: AssetType
+    }
+    export interface unlinkauth {
+        account: NameType
+        code: NameType
+        type: NameType
+        authorized_by?: NameType
+    }
+    export interface unregprod {
+        producer: NameType
+    }
+    export interface unstaketorex {
+        owner: NameType
+        receiver: NameType
+        from_net: AssetType
+        from_cpu: AssetType
+    }
+    export interface updateauth {
+        account: NameType
+        permission: NameType
+        parent: NameType
+        auth: Types.authority
+        authorized_by?: NameType
+    }
+    export interface updaterex {
+        owner: NameType
+    }
+    export interface updtrevision {
+        revision: UInt8Type
+    }
+    export interface voteproducer {
+        voter: NameType
+        proxy: NameType
+        producers: NameType[]
+    }
+    export interface voteupdate {
+        voter_name: NameType
+    }
+    export interface wasmcfg {
+        settings: NameType
+    }
+    export interface withdraw {
+        owner: NameType
+        amount: AssetType
+    }
+}
+export namespace Types {
+    @Struct.type('key_weight')
+    export class key_weight extends Struct {
+        @Struct.field(PublicKey)
+        key!: PublicKey
+        @Struct.field(UInt16)
+        weight!: UInt16
+    }
+    @Struct.type('block_signing_authority_v0')
+    export class block_signing_authority_v0 extends Struct {
+        @Struct.field(UInt32)
+        threshold!: UInt32
+        @Struct.field(key_weight, {array: true})
+        keys!: key_weight[]
+    }
+    @Variant.type('variant_block_signing_authority_v0', [block_signing_authority_v0])
+    export class variant_block_signing_authority_v0 extends Struct {
+        value!: block_signing_authority_v0
+    }
+    @Struct.type('abi_hash')
+    export class abi_hash extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Checksum256)
+        hash!: Checksum256
+    }
+    @Struct.type('activate')
+    export class activate extends Struct {
+        @Struct.field(Checksum256)
+        feature_digest!: Checksum256
+    }
+    @Struct.type('permission_level')
+    export class permission_level extends Struct {
+        @Struct.field(Name)
+        actor!: Name
+        @Struct.field(Name)
+        permission!: Name
+    }
+    @Struct.type('permission_level_weight')
+    export class permission_level_weight extends Struct {
+        @Struct.field(permission_level)
+        permission!: permission_level
+        @Struct.field(UInt16)
+        weight!: UInt16
+    }
+    @Struct.type('wait_weight')
+    export class wait_weight extends Struct {
+        @Struct.field(UInt32)
+        wait_sec!: UInt32
+        @Struct.field(UInt16)
+        weight!: UInt16
+    }
+    @Struct.type('authority')
+    export class authority extends Struct {
+        @Struct.field(UInt32)
+        threshold!: UInt32
+        @Struct.field(key_weight, {array: true})
+        keys!: key_weight[]
+        @Struct.field(permission_level_weight, {array: true})
+        accounts!: permission_level_weight[]
+        @Struct.field(wait_weight, {array: true})
+        waits!: wait_weight[]
+    }
+    @Struct.type('bid_refund')
+    export class bid_refund extends Struct {
+        @Struct.field(Name)
+        bidder!: Name
+        @Struct.field(Asset)
+        amount!: Asset
+    }
+    @Struct.type('bidname')
+    export class bidname extends Struct {
+        @Struct.field(Name)
+        bidder!: Name
+        @Struct.field(Name)
+        newname!: Name
+        @Struct.field(Asset)
+        bid!: Asset
+    }
+    @Struct.type('bidrefund')
+    export class bidrefund extends Struct {
+        @Struct.field(Name)
+        bidder!: Name
+        @Struct.field(Name)
+        newname!: Name
+    }
+    @Struct.type('producer_key')
+    export class producer_key extends Struct {
+        @Struct.field(Name)
+        producer_name!: Name
+        @Struct.field(PublicKey)
+        block_signing_key!: PublicKey
+    }
+    @Struct.type('producer_schedule')
+    export class producer_schedule extends Struct {
+        @Struct.field(UInt32)
+        version!: UInt32
+        @Struct.field(producer_key, {array: true})
+        producers!: producer_key[]
+    }
+    @Struct.type('block_header')
+    export class block_header extends Struct {
+        @Struct.field(UInt32)
+        timestamp!: UInt32
+        @Struct.field(Name)
+        producer!: Name
+        @Struct.field(UInt16)
+        confirmed!: UInt16
+        @Struct.field(Checksum256)
+        previous!: Checksum256
+        @Struct.field(Checksum256)
+        transaction_mroot!: Checksum256
+        @Struct.field(Checksum256)
+        action_mroot!: Checksum256
+        @Struct.field(UInt32)
+        schedule_version!: UInt32
+        @Struct.field(producer_schedule, {optional: true})
+        new_producers?: producer_schedule
+    }
+    @Struct.type('block_info_record')
+    export class block_info_record extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(UInt32)
+        block_height!: UInt32
+        @Struct.field(TimePoint)
+        block_timestamp!: TimePoint
+    }
+    @Struct.type('blockchain_parameters')
+    export class blockchain_parameters extends Struct {
+        @Struct.field(UInt64)
+        max_block_net_usage!: UInt64
+        @Struct.field(UInt32)
+        target_block_net_usage_pct!: UInt32
+        @Struct.field(UInt32)
+        max_transaction_net_usage!: UInt32
+        @Struct.field(UInt32)
+        base_per_transaction_net_usage!: UInt32
+        @Struct.field(UInt32)
+        net_usage_leeway!: UInt32
+        @Struct.field(UInt32)
+        context_free_discount_net_usage_num!: UInt32
+        @Struct.field(UInt32)
+        context_free_discount_net_usage_den!: UInt32
+        @Struct.field(UInt32)
+        max_block_cpu_usage!: UInt32
+        @Struct.field(UInt32)
+        target_block_cpu_usage_pct!: UInt32
+        @Struct.field(UInt32)
+        max_transaction_cpu_usage!: UInt32
+        @Struct.field(UInt32)
+        min_transaction_cpu_usage!: UInt32
+        @Struct.field(UInt32)
+        max_transaction_lifetime!: UInt32
+        @Struct.field(UInt32)
+        deferred_trx_expiration_window!: UInt32
+        @Struct.field(UInt32)
+        max_transaction_delay!: UInt32
+        @Struct.field(UInt32)
+        max_inline_action_size!: UInt32
+        @Struct.field(UInt16)
+        max_inline_action_depth!: UInt16
+        @Struct.field(UInt16)
+        max_authority_depth!: UInt16
+    }
+    @Struct.type('blockchain_parameters_v1')
+    export class blockchain_parameters_v1 extends Struct {
+        @Struct.field(UInt32, {optional: true})
+        max_action_return_value_size?: UInt32
+    }
+    @Struct.type('buyram')
+    export class buyram extends Struct {
+        @Struct.field(Name)
+        payer!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(Asset)
+        quant!: Asset
+    }
+    @Struct.type('buyrambytes')
+    export class buyrambytes extends Struct {
+        @Struct.field(Name)
+        payer!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(UInt32)
+        bytes!: UInt32
+    }
+    @Struct.type('buyrex')
+    export class buyrex extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(Asset)
+        amount!: Asset
+    }
+    @Struct.type('canceldelay')
+    export class canceldelay extends Struct {
+        @Struct.field(permission_level)
+        canceling_auth!: permission_level
+        @Struct.field(Checksum256)
+        trx_id!: Checksum256
+    }
+    @Struct.type('powerup_config_resource')
+    export class powerup_config_resource extends Struct {
+        @Struct.field(Int64, {optional: true})
+        current_weight_ratio?: Int64
+        @Struct.field(Int64, {optional: true})
+        target_weight_ratio?: Int64
+        @Struct.field(Int64, {optional: true})
+        assumed_stake_weight?: Int64
+        @Struct.field(TimePointSec, {optional: true})
+        target_timestamp?: TimePointSec
+        @Struct.field(Float64, {optional: true})
+        exponent?: Float64
+        @Struct.field(UInt32, {optional: true})
+        decay_secs?: UInt32
+        @Struct.field(Asset, {optional: true})
+        min_price?: Asset
+        @Struct.field(Asset, {optional: true})
+        max_price?: Asset
+    }
+    @Struct.type('powerup_config')
+    export class powerup_config extends Struct {
+        @Struct.field(powerup_config_resource)
+        net!: powerup_config_resource
+        @Struct.field(powerup_config_resource)
+        cpu!: powerup_config_resource
+        @Struct.field(UInt32, {optional: true})
+        powerup_days?: UInt32
+        @Struct.field(Asset, {optional: true})
+        min_powerup_fee?: Asset
+    }
+    @Struct.type('cfgpowerup')
+    export class cfgpowerup extends Struct {
+        @Struct.field(powerup_config)
+        args!: powerup_config
+    }
+    @Struct.type('claimrewards')
+    export class claimrewards extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+    }
+    @Struct.type('closerex')
+    export class closerex extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+    }
+    @Struct.type('cnclrexorder')
+    export class cnclrexorder extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+    }
+    @Struct.type('connector')
+    export class connector extends Struct {
+        @Struct.field(Asset)
+        balance!: Asset
+        @Struct.field(Float64)
+        weight!: Float64
+    }
+    @Struct.type('consolidate')
+    export class consolidate extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+    }
+    @Struct.type('defcpuloan')
+    export class defcpuloan extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(UInt64)
+        loan_num!: UInt64
+        @Struct.field(Asset)
+        amount!: Asset
+    }
+    @Struct.type('defnetloan')
+    export class defnetloan extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(UInt64)
+        loan_num!: UInt64
+        @Struct.field(Asset)
+        amount!: Asset
+    }
+    @Struct.type('delegatebw')
+    export class delegatebw extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(Asset)
+        stake_net_quantity!: Asset
+        @Struct.field(Asset)
+        stake_cpu_quantity!: Asset
+        @Struct.field('bool')
+        transfer!: boolean
+    }
+    @Struct.type('delegated_bandwidth')
+    export class delegated_bandwidth extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(Name)
+        to!: Name
+        @Struct.field(Asset)
+        net_weight!: Asset
+        @Struct.field(Asset)
+        cpu_weight!: Asset
+    }
+    @Struct.type('deleteauth')
+    export class deleteauth extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Name)
+        permission!: Name
+        @Struct.field(Name, {optional: true})
+        authorized_by?: Name
+    }
+    @Struct.type('deposit')
+    export class deposit extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Asset)
+        amount!: Asset
+    }
+    @Struct.type('eosio_global_state')
+    export class eosio_global_state extends Struct {
+        @Struct.field(UInt64)
+        max_ram_size!: UInt64
+        @Struct.field(UInt64)
+        total_ram_bytes_reserved!: UInt64
+        @Struct.field(Int64)
+        total_ram_stake!: Int64
+        @Struct.field(BlockTimestamp)
+        last_producer_schedule_update!: BlockTimestamp
+        @Struct.field(TimePoint)
+        last_pervote_bucket_fill!: TimePoint
+        @Struct.field(Int64)
+        pervote_bucket!: Int64
+        @Struct.field(Int64)
+        perblock_bucket!: Int64
+        @Struct.field(UInt32)
+        total_unpaid_blocks!: UInt32
+        @Struct.field(Int64)
+        total_activated_stake!: Int64
+        @Struct.field(TimePoint)
+        thresh_activated_stake_time!: TimePoint
+        @Struct.field(UInt16)
+        last_producer_schedule_size!: UInt16
+        @Struct.field(Float64)
+        total_producer_vote_weight!: Float64
+        @Struct.field(BlockTimestamp)
+        last_name_close!: BlockTimestamp
+    }
+    @Struct.type('eosio_global_state2')
+    export class eosio_global_state2 extends Struct {
+        @Struct.field(UInt16)
+        new_ram_per_block!: UInt16
+        @Struct.field(BlockTimestamp)
+        last_ram_increase!: BlockTimestamp
+        @Struct.field(BlockTimestamp)
+        last_block_num!: BlockTimestamp
+        @Struct.field(Float64)
+        total_producer_votepay_share!: Float64
+        @Struct.field(UInt8)
+        revision!: UInt8
+    }
+    @Struct.type('eosio_global_state3')
+    export class eosio_global_state3 extends Struct {
+        @Struct.field(TimePoint)
+        last_vpay_state_update!: TimePoint
+        @Struct.field(Float64)
+        total_vpay_share_change_rate!: Float64
+    }
+    @Struct.type('eosio_global_state4')
+    export class eosio_global_state4 extends Struct {
+        @Struct.field(Float64)
+        continuous_rate!: Float64
+        @Struct.field(Int64)
+        inflation_pay_factor!: Int64
+        @Struct.field(Int64)
+        votepay_factor!: Int64
+    }
+    @Struct.type('exchange_state')
+    export class exchange_state extends Struct {
+        @Struct.field(Asset)
+        supply!: Asset
+        @Struct.field(connector)
+        base!: connector
+        @Struct.field(connector)
+        quote!: connector
+    }
+    @Struct.type('fundcpuloan')
+    export class fundcpuloan extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(UInt64)
+        loan_num!: UInt64
+        @Struct.field(Asset)
+        payment!: Asset
+    }
+    @Struct.type('fundnetloan')
+    export class fundnetloan extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(UInt64)
+        loan_num!: UInt64
+        @Struct.field(Asset)
+        payment!: Asset
+    }
+    @Struct.type('init')
+    export class init extends Struct {
+        @Struct.field(VarUInt)
+        version!: VarUInt
+        @Struct.field(Asset.Symbol)
+        core!: Asset.Symbol
+    }
+    @Struct.type('limitauthchg')
+    export class limitauthchg extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Name, {array: true})
+        allow_perms!: Name[]
+        @Struct.field(Name, {array: true})
+        disallow_perms!: Name[]
+    }
+    @Struct.type('linkauth')
+    export class linkauth extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Name)
+        code!: Name
+        @Struct.field(Name)
+        type!: Name
+        @Struct.field(Name)
+        requirement!: Name
+        @Struct.field(Name, {optional: true})
+        authorized_by?: Name
+    }
+    @Struct.type('mvfrsavings')
+    export class mvfrsavings extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Asset)
+        rex!: Asset
+    }
+    @Struct.type('mvtosavings')
+    export class mvtosavings extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Asset)
+        rex!: Asset
+    }
+    @Struct.type('name_bid')
+    export class name_bid extends Struct {
+        @Struct.field(Name)
+        newname!: Name
+        @Struct.field(Name)
+        high_bidder!: Name
+        @Struct.field(Int64)
+        high_bid!: Int64
+        @Struct.field(TimePoint)
+        last_bid_time!: TimePoint
+    }
+    @Struct.type('newaccount')
+    export class newaccount extends Struct {
+        @Struct.field(Name)
+        creator!: Name
+        @Struct.field(Name)
+        name!: Name
+        @Struct.field(authority)
+        owner!: authority
+        @Struct.field(authority)
+        active!: authority
+    }
+    @Struct.type('onblock')
+    export class onblock extends Struct {
+        @Struct.field(block_header)
+        header!: block_header
+    }
+    @Struct.type('onerror')
+    export class onerror extends Struct {
+        @Struct.field(UInt128)
+        sender_id!: UInt128
+        @Struct.field(Bytes)
+        sent_trx!: Bytes
+    }
+    @Struct.type('pair_time_point_sec_int64')
+    export class pair_time_point_sec_int64 extends Struct {
+        @Struct.field(TimePointSec)
+        first!: TimePointSec
+        @Struct.field(Int64)
+        second!: Int64
+    }
+    @Struct.type('powerup')
+    export class powerup extends Struct {
+        @Struct.field(Name)
+        payer!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(UInt32)
+        days!: UInt32
+        @Struct.field(Int64)
+        net_frac!: Int64
+        @Struct.field(Int64)
+        cpu_frac!: Int64
+        @Struct.field(Asset)
+        max_payment!: Asset
+    }
+    @Struct.type('powerup_order')
+    export class powerup_order extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(UInt64)
+        id!: UInt64
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Int64)
+        net_weight!: Int64
+        @Struct.field(Int64)
+        cpu_weight!: Int64
+        @Struct.field(TimePointSec)
+        expires!: TimePointSec
+    }
+    @Struct.type('powerup_state_resource')
+    export class powerup_state_resource extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(Int64)
+        weight!: Int64
+        @Struct.field(Int64)
+        weight_ratio!: Int64
+        @Struct.field(Int64)
+        assumed_stake_weight!: Int64
+        @Struct.field(Int64)
+        initial_weight_ratio!: Int64
+        @Struct.field(Int64)
+        target_weight_ratio!: Int64
+        @Struct.field(TimePointSec)
+        initial_timestamp!: TimePointSec
+        @Struct.field(TimePointSec)
+        target_timestamp!: TimePointSec
+        @Struct.field(Float64)
+        exponent!: Float64
+        @Struct.field(UInt32)
+        decay_secs!: UInt32
+        @Struct.field(Asset)
+        min_price!: Asset
+        @Struct.field(Asset)
+        max_price!: Asset
+        @Struct.field(Int64)
+        utilization!: Int64
+        @Struct.field(Int64)
+        adjusted_utilization!: Int64
+        @Struct.field(TimePointSec)
+        utilization_timestamp!: TimePointSec
+    }
+    @Struct.type('powerup_state')
+    export class powerup_state extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(powerup_state_resource)
+        net!: powerup_state_resource
+        @Struct.field(powerup_state_resource)
+        cpu!: powerup_state_resource
+        @Struct.field(UInt32)
+        powerup_days!: UInt32
+        @Struct.field(Asset)
+        min_powerup_fee!: Asset
+    }
+    @Struct.type('powerupexec')
+    export class powerupexec extends Struct {
+        @Struct.field(Name)
+        user!: Name
+        @Struct.field(UInt16)
+        max!: UInt16
+    }
+    @Struct.type('producer_info')
+    export class producer_info extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Float64)
+        total_votes!: Float64
+        @Struct.field(PublicKey)
+        producer_key!: PublicKey
+        @Struct.field('bool')
+        is_active!: boolean
+        @Struct.field('string')
+        url!: string
+        @Struct.field(UInt32)
+        unpaid_blocks!: UInt32
+        @Struct.field(TimePoint)
+        last_claim_time!: TimePoint
+        @Struct.field(UInt16)
+        location!: UInt16
+        @Struct.field(variant_block_signing_authority_v0, {optional: true})
+        producer_authority?: variant_block_signing_authority_v0
+    }
+    @Struct.type('producer_info2')
+    export class producer_info2 extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Float64)
+        votepay_share!: Float64
+        @Struct.field(TimePoint)
+        last_votepay_share_update!: TimePoint
+    }
+    @Struct.type('refund')
+    export class refund extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+    }
+    @Struct.type('refund_request')
+    export class refund_request extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(TimePointSec)
+        request_time!: TimePointSec
+        @Struct.field(Asset)
+        net_amount!: Asset
+        @Struct.field(Asset)
+        cpu_amount!: Asset
+    }
+    @Struct.type('regproducer')
+    export class regproducer extends Struct {
+        @Struct.field(Name)
+        producer!: Name
+        @Struct.field(PublicKey)
+        producer_key!: PublicKey
+        @Struct.field('string')
+        url!: string
+        @Struct.field(UInt16)
+        location!: UInt16
+    }
+    @Struct.type('regproducer2')
+    export class regproducer2 extends Struct {
+        @Struct.field(Name)
+        producer!: Name
+        @Struct.field(variant_block_signing_authority_v0)
+        producer_authority!: variant_block_signing_authority_v0
+        @Struct.field('string')
+        url!: string
+        @Struct.field(UInt16)
+        location!: UInt16
+    }
+    @Struct.type('regproxy')
+    export class regproxy extends Struct {
+        @Struct.field(Name)
+        proxy!: Name
+        @Struct.field('bool')
+        isproxy!: boolean
+    }
+    @Struct.type('rentcpu')
+    export class rentcpu extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(Asset)
+        loan_payment!: Asset
+        @Struct.field(Asset)
+        loan_fund!: Asset
+    }
+    @Struct.type('rentnet')
+    export class rentnet extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(Asset)
+        loan_payment!: Asset
+        @Struct.field(Asset)
+        loan_fund!: Asset
+    }
+    @Struct.type('rex_balance')
+    export class rex_balance extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Asset)
+        vote_stake!: Asset
+        @Struct.field(Asset)
+        rex_balance!: Asset
+        @Struct.field(Int64)
+        matured_rex!: Int64
+        @Struct.field(pair_time_point_sec_int64, {array: true})
+        rex_maturities!: pair_time_point_sec_int64[]
+    }
+    @Struct.type('rex_fund')
+    export class rex_fund extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Asset)
+        balance!: Asset
+    }
+    @Struct.type('rex_loan')
+    export class rex_loan extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(Asset)
+        payment!: Asset
+        @Struct.field(Asset)
+        balance!: Asset
+        @Struct.field(Asset)
+        total_staked!: Asset
+        @Struct.field(UInt64)
+        loan_num!: UInt64
+        @Struct.field(TimePoint)
+        expiration!: TimePoint
+    }
+    @Struct.type('rex_order')
+    export class rex_order extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Asset)
+        rex_requested!: Asset
+        @Struct.field(Asset)
+        proceeds!: Asset
+        @Struct.field(Asset)
+        stake_change!: Asset
+        @Struct.field(TimePoint)
+        order_time!: TimePoint
+        @Struct.field('bool')
+        is_open!: boolean
+    }
+    @Struct.type('rex_pool')
+    export class rex_pool extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(Asset)
+        total_lent!: Asset
+        @Struct.field(Asset)
+        total_unlent!: Asset
+        @Struct.field(Asset)
+        total_rent!: Asset
+        @Struct.field(Asset)
+        total_lendable!: Asset
+        @Struct.field(Asset)
+        total_rex!: Asset
+        @Struct.field(Asset)
+        namebid_proceeds!: Asset
+        @Struct.field(UInt64)
+        loan_num!: UInt64
+    }
+    @Struct.type('rex_return_buckets')
+    export class rex_return_buckets extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(pair_time_point_sec_int64, {array: true})
+        return_buckets!: pair_time_point_sec_int64[]
+    }
+    @Struct.type('rex_return_pool')
+    export class rex_return_pool extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(TimePointSec)
+        last_dist_time!: TimePointSec
+        @Struct.field(TimePointSec)
+        pending_bucket_time!: TimePointSec
+        @Struct.field(TimePointSec)
+        oldest_bucket_time!: TimePointSec
+        @Struct.field(Int64)
+        pending_bucket_proceeds!: Int64
+        @Struct.field(Int64)
+        current_rate_of_increase!: Int64
+        @Struct.field(Int64)
+        proceeds!: Int64
+    }
+    @Struct.type('rexexec')
+    export class rexexec extends Struct {
+        @Struct.field(Name)
+        user!: Name
+        @Struct.field(UInt16)
+        max!: UInt16
+    }
+    @Struct.type('rmvproducer')
+    export class rmvproducer extends Struct {
+        @Struct.field(Name)
+        producer!: Name
+    }
+    @Struct.type('sellram')
+    export class sellram extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Int64)
+        bytes!: Int64
+    }
+    @Struct.type('sellrex')
+    export class sellrex extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(Asset)
+        rex!: Asset
+    }
+    @Struct.type('setabi')
+    export class setabi extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Bytes)
+        abi!: Bytes
+        @Struct.field('string', {optional: true})
+        memo?: string
+    }
+    @Struct.type('setacctcpu')
+    export class setacctcpu extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Int64, {optional: true})
+        cpu_weight?: Int64
+    }
+    @Struct.type('setacctnet')
+    export class setacctnet extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Int64, {optional: true})
+        net_weight?: Int64
+    }
+    @Struct.type('setacctram')
+    export class setacctram extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Int64, {optional: true})
+        ram_bytes?: Int64
+    }
+    @Struct.type('setalimits')
+    export class setalimits extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Int64)
+        ram_bytes!: Int64
+        @Struct.field(Int64)
+        net_weight!: Int64
+        @Struct.field(Int64)
+        cpu_weight!: Int64
+    }
+    @Struct.type('setcode')
+    export class setcode extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(UInt8)
+        vmtype!: UInt8
+        @Struct.field(UInt8)
+        vmversion!: UInt8
+        @Struct.field(Bytes)
+        code!: Bytes
+        @Struct.field('string', {optional: true})
+        memo?: string
+    }
+    @Struct.type('setinflation')
+    export class setinflation extends Struct {
+        @Struct.field(Int64)
+        annual_rate!: Int64
+        @Struct.field(Int64)
+        inflation_pay_factor!: Int64
+        @Struct.field(Int64)
+        votepay_factor!: Int64
+    }
+    @Struct.type('setparams')
+    export class setparams extends Struct {
+        @Struct.field(blockchain_parameters_v1)
+        params!: blockchain_parameters_v1
+    }
+    @Struct.type('setpriv')
+    export class setpriv extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(UInt8)
+        is_priv!: UInt8
+    }
+    @Struct.type('setram')
+    export class setram extends Struct {
+        @Struct.field(UInt64)
+        max_ram_size!: UInt64
+    }
+    @Struct.type('setramrate')
+    export class setramrate extends Struct {
+        @Struct.field(UInt16)
+        bytes_per_block!: UInt16
+    }
+    @Struct.type('setrex')
+    export class setrex extends Struct {
+        @Struct.field(Asset)
+        balance!: Asset
+    }
+    @Struct.type('undelegatebw')
+    export class undelegatebw extends Struct {
+        @Struct.field(Name)
+        from!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(Asset)
+        unstake_net_quantity!: Asset
+        @Struct.field(Asset)
+        unstake_cpu_quantity!: Asset
+    }
+    @Struct.type('unlinkauth')
+    export class unlinkauth extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Name)
+        code!: Name
+        @Struct.field(Name)
+        type!: Name
+        @Struct.field(Name, {optional: true})
+        authorized_by?: Name
+    }
+    @Struct.type('unregprod')
+    export class unregprod extends Struct {
+        @Struct.field(Name)
+        producer!: Name
+    }
+    @Struct.type('unstaketorex')
+    export class unstaketorex extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Name)
+        receiver!: Name
+        @Struct.field(Asset)
+        from_net!: Asset
+        @Struct.field(Asset)
+        from_cpu!: Asset
+    }
+    @Struct.type('updateauth')
+    export class updateauth extends Struct {
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Name)
+        permission!: Name
+        @Struct.field(Name)
+        parent!: Name
+        @Struct.field(authority)
+        auth!: authority
+        @Struct.field(Name, {optional: true})
+        authorized_by?: Name
+    }
+    @Struct.type('updaterex')
+    export class updaterex extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+    }
+    @Struct.type('updtrevision')
+    export class updtrevision extends Struct {
+        @Struct.field(UInt8)
+        revision!: UInt8
+    }
+    @Struct.type('user_resources')
+    export class user_resources extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Asset)
+        net_weight!: Asset
+        @Struct.field(Asset)
+        cpu_weight!: Asset
+        @Struct.field(Int64)
+        ram_bytes!: Int64
+    }
+    @Struct.type('voteproducer')
+    export class voteproducer extends Struct {
+        @Struct.field(Name)
+        voter!: Name
+        @Struct.field(Name)
+        proxy!: Name
+        @Struct.field(Name, {array: true})
+        producers!: Name[]
+    }
+    @Struct.type('voter_info')
+    export class voter_info extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Name)
+        proxy!: Name
+        @Struct.field(Name, {array: true})
+        producers!: Name[]
+        @Struct.field(Int64)
+        staked!: Int64
+        @Struct.field(Float64)
+        last_vote_weight!: Float64
+        @Struct.field(Float64)
+        proxied_vote_weight!: Float64
+        @Struct.field('bool')
+        is_proxy!: boolean
+        @Struct.field(UInt32)
+        flags1!: UInt32
+        @Struct.field(UInt32)
+        reserved2!: UInt32
+        @Struct.field(Asset)
+        reserved3!: Asset
+    }
+    @Struct.type('voteupdate')
+    export class voteupdate extends Struct {
+        @Struct.field(Name)
+        voter_name!: Name
+    }
+    @Struct.type('wasmcfg')
+    export class wasmcfg extends Struct {
+        @Struct.field(Name)
+        settings!: Name
+    }
+    @Struct.type('withdraw')
+    export class withdraw extends Struct {
+        @Struct.field(Name)
+        owner!: Name
+        @Struct.field(Asset)
+        amount!: Asset
+    }
+    @Struct.type('limit_auth_change')
+    export class limit_auth_change extends Struct {
+        @Struct.field(UInt8)
+        version!: UInt8
+        @Struct.field(Name)
+        account!: Name
+        @Struct.field(Name, {array: true})
+        allow_perms!: Name[]
+        @Struct.field(Name, {array: true})
+        disallow_perms!: Name[]
+    }
+}
+export const TableMap = {
+    abihash: Types.abi_hash,
+    bidrefunds: Types.bid_refund,
+    blockinfo: Types.block_info_record,
+    cpuloan: Types.rex_loan,
+    delband: Types.delegated_bandwidth,
+    global: Types.eosio_global_state,
+    global2: Types.eosio_global_state2,
+    global3: Types.eosio_global_state3,
+    global4: Types.eosio_global_state4,
+    namebids: Types.name_bid,
+    netloan: Types.rex_loan,
+    'powup.order': Types.powerup_order,
+    'powup.state': Types.powerup_state,
+    producers: Types.producer_info,
+    producers2: Types.producer_info2,
+    rammarket: Types.exchange_state,
+    refunds: Types.refund_request,
+    retbuckets: Types.rex_return_buckets,
+    rexbal: Types.rex_balance,
+    rexfund: Types.rex_fund,
+    rexpool: Types.rex_pool,
+    rexqueue: Types.rex_order,
+    rexretpool: Types.rex_return_pool,
+    userres: Types.user_resources,
+    voters: Types.voter_info,
+    limitauthchg: Types.limit_auth_change,
+}
+export interface TableTypes {
+    abihash: Types.abi_hash
+    bidrefunds: Types.bid_refund
+    blockinfo: Types.block_info_record
+    cpuloan: Types.rex_loan
+    delband: Types.delegated_bandwidth
+    global: Types.eosio_global_state
+    global2: Types.eosio_global_state2
+    global3: Types.eosio_global_state3
+    global4: Types.eosio_global_state4
+    namebids: Types.name_bid
+    netloan: Types.rex_loan
+    'powup.order': Types.powerup_order
+    'powup.state': Types.powerup_state
+    producers: Types.producer_info
+    producers2: Types.producer_info2
+    rammarket: Types.exchange_state
+    refunds: Types.refund_request
+    retbuckets: Types.rex_return_buckets
+    rexbal: Types.rex_balance
+    rexfund: Types.rex_fund
+    rexpool: Types.rex_pool
+    rexqueue: Types.rex_order
+    rexretpool: Types.rex_return_pool
+    userres: Types.user_resources
+    voters: Types.voter_info
+    limitauthchg: Types.limit_auth_change
+}
+export type RowType<T> = T extends keyof TableTypes ? TableTypes[T] : any
+export type ActionNames = keyof ActionNameParams
+export type TableNames = keyof TableTypes
diff --git a/test/utils/codegen.ts b/test/utils/codegen.ts
index 1d93d96..e3c2e4f 100644
--- a/test/utils/codegen.ts
+++ b/test/utils/codegen.ts
@@ -28,5 +28,5 @@ export async function generateCodegenContract(contractName: string) {
 }
 
 export function removeCodegenContracts() {
-    fs.rmSync('test/tmp', {recursive: true, force: true})
+    // fs.rmSync('test/tmp', {recursive: true, force: true})
 }