// Auto-generated via `yarn polkadot-types-from-defs`, do not edit
/* eslint-disable */
/* eslint-disable sort-keys */
export default {
    /**
     * Lookup3: frame_system::AccountInfo<Index, AccountData>
     **/
    FrameSystemAccountInfo: {
        nonce: 'u32',
        consumers: 'u32',
        providers: 'u32',
        sufficients: 'u32',
        data: 'Null'
    },
    /**
     * Lookup6: frame_support::weights::PerDispatchClass<T>
     **/
    FrameSupportWeightsPerDispatchClassU64: {
        normal: 'u64',
        operational: 'u64',
        mandatory: 'u64'
    },
    /**
     * Lookup10: sp_runtime::generic::digest::Digest
     **/
    SpRuntimeDigest: {
        logs: 'Vec<SpRuntimeDigestDigestItem>'
    },
    /**
     * Lookup12: sp_runtime::generic::digest::DigestItem
     **/
    SpRuntimeDigestDigestItem: {
        _enum: {
            Other: 'Bytes',
            __Unused1: 'Null',
            __Unused2: 'Null',
            __Unused3: 'Null',
            Consensus: '([u8;4],Bytes)',
            Seal: '([u8;4],Bytes)',
            PreRuntime: '([u8;4],Bytes)',
            __Unused7: 'Null',
            RuntimeEnvironmentUpdated: 'Null'
        }
    },
    /**
     * Lookup15: frame_system::EventRecord<eq_node_runtime::Event, primitive_types::H256>
     **/
    FrameSystemEventRecord: {
        phase: 'FrameSystemPhase',
        event: 'Event',
        topics: 'Vec<H256>'
    },
    /**
     * Lookup17: frame_system::pallet::Event<T>
     **/
    FrameSystemEvent: {
        _enum: {
            ExtrinsicSuccess: {
                dispatchInfo: 'FrameSupportWeightsDispatchInfo',
            },
            ExtrinsicFailed: {
                dispatchError: 'SpRuntimeDispatchError',
                dispatchInfo: 'FrameSupportWeightsDispatchInfo',
            },
            CodeUpdated: 'Null',
            NewAccount: {
                account: 'AccountId32',
            },
            KilledAccount: {
                account: 'AccountId32',
            },
            Remarked: {
                _alias: {
                    hash_: 'hash',
                },
                sender: 'AccountId32',
                hash_: 'H256'
            }
        }
    },
    /**
     * Lookup18: frame_support::weights::DispatchInfo
     **/
    FrameSupportWeightsDispatchInfo: {
        weight: 'u64',
        class: 'FrameSupportWeightsDispatchClass',
        paysFee: 'FrameSupportWeightsPays'
    },
    /**
     * Lookup19: frame_support::weights::DispatchClass
     **/
    FrameSupportWeightsDispatchClass: {
        _enum: ['Normal', 'Operational', 'Mandatory']
    },
    /**
     * Lookup20: frame_support::weights::Pays
     **/
    FrameSupportWeightsPays: {
        _enum: ['Yes', 'No']
    },
    /**
     * Lookup21: sp_runtime::DispatchError
     **/
    SpRuntimeDispatchError: {
        _enum: {
            Other: 'Null',
            CannotLookup: 'Null',
            BadOrigin: 'Null',
            Module: 'SpRuntimeModuleError',
            ConsumerRemaining: 'Null',
            NoProviders: 'Null',
            TooManyConsumers: 'Null',
            Token: 'SpRuntimeTokenError',
            Arithmetic: 'SpRuntimeArithmeticError'
        }
    },
    /**
     * Lookup22: sp_runtime::ModuleError
     **/
    SpRuntimeModuleError: {
        index: 'u8',
        error: 'u8'
    },
    /**
     * Lookup23: sp_runtime::TokenError
     **/
    SpRuntimeTokenError: {
        _enum: ['NoFunds', 'WouldDie', 'BelowMinimum', 'CannotCreate', 'UnknownAsset', 'Frozen', 'Unsupported']
    },
    /**
     * Lookup24: sp_runtime::ArithmeticError
     **/
    SpRuntimeArithmeticError: {
        _enum: ['Underflow', 'Overflow', 'DivisionByZero']
    },
    /**
     * Lookup25: cumulus_pallet_parachain_system::pallet::Event<T>
     **/
    CumulusPalletParachainSystemEvent: {
        _enum: {
            ValidationFunctionStored: 'Null',
            ValidationFunctionApplied: 'u32',
            ValidationFunctionDiscarded: 'Null',
            UpgradeAuthorized: 'H256',
            DownwardMessagesReceived: 'u32',
            DownwardMessagesProcessed: '(u64,H256)'
        }
    },
    /**
     * Lookup26: pallet_utility::pallet::Event
     **/
    PalletUtilityEvent: {
        _enum: {
            BatchInterrupted: {
                index: 'u32',
                error: 'SpRuntimeDispatchError',
            },
            BatchCompleted: 'Null',
            ItemCompleted: 'Null',
            DispatchedAs: {
                result: 'Result<Null, SpRuntimeDispatchError>'
            }
        }
    },
    /**
     * Lookup28: eq_session_manager::pallet::Event<T>
     **/
    EqSessionManagerEvent: {
        _enum: {
            ValidatorAdded: 'AccountId32',
            ValidatorRemoved: 'AccountId32'
        }
    },
    /**
     * Lookup29: pallet_session::pallet::Event
     **/
    PalletSessionEvent: {
        _enum: {
            NewSession: {
                sessionIndex: 'u32'
            }
        }
    },
    /**
     * Lookup30: eq_assets::pallet::Event
     **/
    EqAssetsEvent: {
        _enum: {
            NewAsset: '(u64,Bytes)',
            DeleteAsset: '(u64,Bytes)',
            UpdateAsset: '(u64,Bytes)'
        }
    },
    /**
     * Lookup31: eq_balances::pallet::Event<T>
     **/
    EqBalancesEvent: {
        _enum: {
            Transfer: '(AccountId32,AccountId32,u64,u128,EqPrimitivesTransferReason)',
            DeleteAccount: 'AccountId32',
            Exchange: '(AccountId32,u64,u128,AccountId32,u64,u128)',
            Deposit: '(AccountId32,u64,u128)',
            Withdraw: '(AccountId32,u64,u128)',
            XcmTransfer: '(AccountId32,XcmV1MultiLocation,u64,XcmV1MultiLocation,u128,u128,XcmV1MultiLocation,[u8;32])'
        }
    },
    /**
     * Lookup34: eq_primitives::TransferReason
     **/
    EqPrimitivesTransferReason: {
        _enum: ['Common', 'InterestFee', 'MarginCall', 'LiquidityFarming', 'BailsmenRedistribution', 'TreasuryEqBuyout', 'TreasuryBuyEq', 'Subaccount', 'Lock', 'Unlock', 'Claim', 'CurveFeeWithdraw', 'Reserve', 'Unreserve']
    },
    /**
     * Lookup35: xcm::v1::multilocation::MultiLocation
     **/
    XcmV1MultiLocation: {
        parents: 'u8',
        interior: 'XcmV1MultilocationJunctions'
    },
    /**
     * Lookup36: xcm::v1::multilocation::Junctions
     **/
    XcmV1MultilocationJunctions: {
        _enum: {
            Here: 'Null',
            X1: 'XcmV1Junction',
            X2: '(XcmV1Junction,XcmV1Junction)',
            X3: '(XcmV1Junction,XcmV1Junction,XcmV1Junction)',
            X4: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
            X5: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
            X6: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
            X7: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)',
            X8: '(XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction,XcmV1Junction)'
        }
    },
    /**
     * Lookup37: xcm::v1::junction::Junction
     **/
    XcmV1Junction: {
        _enum: {
            Parachain: 'Compact<u32>',
            AccountId32: {
                network: 'XcmV0JunctionNetworkId',
                id: '[u8;32]',
            },
            AccountIndex64: {
                network: 'XcmV0JunctionNetworkId',
                index: 'Compact<u64>',
            },
            AccountKey20: {
                network: 'XcmV0JunctionNetworkId',
                key: '[u8;20]',
            },
            PalletInstance: 'u8',
            GeneralIndex: 'Compact<u128>',
            GeneralKey: 'Bytes',
            OnlyChild: 'Null',
            Plurality: {
                id: 'XcmV0JunctionBodyId',
                part: 'XcmV0JunctionBodyPart'
            }
        }
    },
    /**
     * Lookup39: xcm::v0::junction::NetworkId
     **/
    XcmV0JunctionNetworkId: {
        _enum: {
            Any: 'Null',
            Named: 'Bytes',
            Polkadot: 'Null',
            Kusama: 'Null'
        }
    },
    /**
     * Lookup43: xcm::v0::junction::BodyId
     **/
    XcmV0JunctionBodyId: {
        _enum: {
            Unit: 'Null',
            Named: 'Bytes',
            Index: 'Compact<u32>',
            Executive: 'Null',
            Technical: 'Null',
            Legislative: 'Null',
            Judicial: 'Null'
        }
    },
    /**
     * Lookup44: xcm::v0::junction::BodyPart
     **/
    XcmV0JunctionBodyPart: {
        _enum: {
            Voice: 'Null',
            Members: {
                count: 'Compact<u32>',
            },
            Fraction: {
                nom: 'Compact<u32>',
                denom: 'Compact<u32>',
            },
            AtLeastProportion: {
                nom: 'Compact<u32>',
                denom: 'Compact<u32>',
            },
            MoreThanProportion: {
                nom: 'Compact<u32>',
                denom: 'Compact<u32>'
            }
        }
    },
    /**
     * Lookup45: pallet_sudo::pallet::Event<T>
     **/
    PalletSudoEvent: {
        _enum: {
            Sudid: {
                sudoResult: 'Result<Null, SpRuntimeDispatchError>',
            },
            KeyChanged: {
                oldSudoer: 'Option<AccountId32>',
            },
            SudoAsDone: {
                sudoResult: 'Result<Null, SpRuntimeDispatchError>'
            }
        }
    },
    /**
     * Lookup47: eq_whitelists::pallet::Event<T>
     **/
    EqWhitelistsEvent: {
        _enum: {
            AddedToWhitelist: 'AccountId32',
            RemovedFromWhitelist: 'AccountId32'
        }
    },
    /**
     * Lookup48: eq_vesting::pallet::Event<T, I>
     **/
    EqVestingEvent: {
        _enum: {
            VestingUpdated: '(AccountId32,u128)',
            VestingCompleted: 'AccountId32'
        }
    },
    /**
     * Lookup50: eq_claim::pallet::Event<T>
     **/
    EqClaimEvent: {
        _enum: {
            Claimed: '(AccountId32,EqClaimEthereumAddress,u128)'
        }
    },
    /**
     * Lookup51: eq_claim::EthereumAddress
     **/
    EqClaimEthereumAddress: '[u8;20]',
    /**
     * Lookup52: eq_subaccounts::pallet::Event<T>
     **/
    EqSubaccountsEvent: {
        _enum: {
            SubaccountCreated: '(AccountId32,AccountId32,EqPrimitivesSubaccountSubAccType)',
            RegisterBailsman: '(AccountId32,AccountId32)'
        }
    },
    /**
     * Lookup53: eq_primitives::subaccount::SubAccType
     **/
    EqPrimitivesSubaccountSubAccType: {
        _enum: ['Bailsman', 'Borrower', 'Lender']
    },
    /**
     * Lookup54: financial_pallet::RawEvent<eq_primitives::asset::Asset, sp_core::crypto::AccountId32>
     **/
    FinancialPalletRawEvent: {
        _enum: {
            AssetMetricsRecalculated: 'u64',
            MetricsRecalculated: 'Null',
            PortfolioMetricsRecalculated: 'AccountId32'
        }
    },
    /**
     * Lookup55: chainbridge::pallet::Event<T>
     **/
    ChainbridgeEvent: {
        _enum: {
            ChainToggled: '(u8,bool)',
            RelayerThresholdChanged: 'u32',
            FeeChanged: '(u8,u128)',
            ProposalLifetimeChanged: 'u32',
            ChainWhitelisted: 'u8',
            RelayerAdded: 'AccountId32',
            RelayerRemoved: 'AccountId32',
            FungibleTransfer: '(u8,u64,[u8;32],U256,Bytes)',
            NonFungibleTransfer: '(u8,u64,[u8;32],Bytes,Bytes,Bytes)',
            GenericTransfer: '(u8,u64,[u8;32],Bytes)',
            VoteFor: '(u8,u64,AccountId32)',
            VoteAgainst: '(u8,u64,AccountId32)',
            ProposalApproved: '(u8,u64)',
            ProposalRejected: '(u8,u64)',
            ProposalSucceeded: '(u8,u64)',
            ProposalFailed: '(u8,u64)'
        }
    },
    /**
     * Lookup59: eq_bridge::pallet::Event<T>
     **/
    EqBridgeEvent: {
        _enum: {
            Remark: 'H256',
            FromBridgeTransfer: '(AccountId32,u64,u128)',
            ToBridgeTransfer: '(AccountId32,u64,u128)',
            MinimumTransferAmountChanged: '(u8,[u8;32],u128)'
        }
    },
    /**
     * Lookup60: eq_multisig_sudo::pallet::Event<T>
     **/
    EqMultisigSudoEvent: {
        _enum: {
            Initialized: 'Null',
            KeyAdded: 'AccountId32',
            KeyRemoved: 'AccountId32',
            ThresholdModified: 'u32',
            NewProposal: '(AccountId32,[u8;32])',
            ProposalCancelled: '[u8;32]',
            ProposalApproved: '(AccountId32,[u8;32])',
            MultisigSudid: '([u8;32],Result<Null, SpRuntimeDispatchError>)',
            SudoFailed: '[u8;32]'
        }
    },
    /**
     * Lookup61: eq_lockdrop::pallet::Event<T>
     **/
    EqLockdropEvent: {
        _enum: {
            Lock: '(AccountId32,u128)',
            Unlock: '(AccountId32,u128)'
        }
    },
    /**
     * Lookup62: pallet_multisig::pallet::Event<T>
     **/
    PalletMultisigEvent: {
        _enum: {
            NewMultisig: {
                approving: 'AccountId32',
                multisig: 'AccountId32',
                callHash: '[u8;32]',
            },
            MultisigApproval: {
                approving: 'AccountId32',
                timepoint: 'PalletMultisigTimepoint',
                multisig: 'AccountId32',
                callHash: '[u8;32]',
            },
            MultisigExecuted: {
                approving: 'AccountId32',
                timepoint: 'PalletMultisigTimepoint',
                multisig: 'AccountId32',
                callHash: '[u8;32]',
                result: 'Result<Null, SpRuntimeDispatchError>',
            },
            MultisigCancelled: {
                cancelling: 'AccountId32',
                timepoint: 'PalletMultisigTimepoint',
                multisig: 'AccountId32',
                callHash: '[u8;32]'
            }
        }
    },
    /**
     * Lookup63: pallet_multisig::Timepoint<BlockNumber>
     **/
    PalletMultisigTimepoint: {
        height: 'u32',
        index: 'u32'
    },
    /**
     * Lookup64: pallet_proxy::pallet::Event<T>
     **/
    PalletProxyEvent: {
        _enum: {
            ProxyExecuted: {
                result: 'Result<Null, SpRuntimeDispatchError>',
            },
            AnonymousCreated: {
                anonymous: 'AccountId32',
                who: 'AccountId32',
                proxyType: 'EqPrimitivesProxyProxyType',
                disambiguationIndex: 'u16',
            },
            Announced: {
                real: 'AccountId32',
                proxy: 'AccountId32',
                callHash: 'H256',
            },
            ProxyAdded: {
                delegator: 'AccountId32',
                delegatee: 'AccountId32',
                proxyType: 'EqPrimitivesProxyProxyType',
                delay: 'u32'
            }
        }
    },
    /**
     * Lookup65: eq_primitives::proxy::ProxyType
     **/
    EqPrimitivesProxyProxyType: {
        _enum: ['Any']
    },
    /**
     * Lookup67: eq_migration::pallet::Event<T>
     **/
    EqMigrationEvent: {
        _enum: {
            MigrationSetted: 'u16',
            MigrationProcessed: 'u16',
            Migrated: 'Null'
        }
    },
    /**
     * Lookup68: pallet_xcm::pallet::Event<T>
     **/
    PalletXcmEvent: {
        _enum: {
            Attempted: 'XcmV2TraitsOutcome',
            Sent: '(XcmV1MultiLocation,XcmV1MultiLocation,XcmV2Xcm)',
            UnexpectedResponse: '(XcmV1MultiLocation,u64)',
            ResponseReady: '(u64,XcmV2Response)',
            Notified: '(u64,u8,u8)',
            NotifyOverweight: '(u64,u8,u8,u64,u64)',
            NotifyDispatchError: '(u64,u8,u8)',
            NotifyDecodeFailed: '(u64,u8,u8)',
            InvalidResponder: '(XcmV1MultiLocation,u64,Option<XcmV1MultiLocation>)',
            InvalidResponderVersion: '(XcmV1MultiLocation,u64)',
            ResponseTaken: 'u64',
            AssetsTrapped: '(H256,XcmV1MultiLocation,XcmVersionedMultiAssets)',
            VersionChangeNotified: '(XcmV1MultiLocation,u32)',
            SupportedVersionChanged: '(XcmV1MultiLocation,u32)',
            NotifyTargetSendFail: '(XcmV1MultiLocation,u64,XcmV2TraitsError)',
            NotifyTargetMigrationFail: '(XcmVersionedMultiLocation,u64)'
        }
    },
    /**
     * Lookup69: xcm::v2::traits::Outcome
     **/
    XcmV2TraitsOutcome: {
        _enum: {
            Complete: 'u64',
            Incomplete: '(u64,XcmV2TraitsError)',
            Error: 'XcmV2TraitsError'
        }
    },
    /**
     * Lookup70: xcm::v2::traits::Error
     **/
    XcmV2TraitsError: {
        _enum: {
            Overflow: 'Null',
            Unimplemented: 'Null',
            UntrustedReserveLocation: 'Null',
            UntrustedTeleportLocation: 'Null',
            MultiLocationFull: 'Null',
            MultiLocationNotInvertible: 'Null',
            BadOrigin: 'Null',
            InvalidLocation: 'Null',
            AssetNotFound: 'Null',
            FailedToTransactAsset: 'Null',
            NotWithdrawable: 'Null',
            LocationCannotHold: 'Null',
            ExceedsMaxMessageSize: 'Null',
            DestinationUnsupported: 'Null',
            Transport: 'Null',
            Unroutable: 'Null',
            UnknownClaim: 'Null',
            FailedToDecode: 'Null',
            MaxWeightInvalid: 'Null',
            NotHoldingFees: 'Null',
            TooExpensive: 'Null',
            Trap: 'u64',
            UnhandledXcmVersion: 'Null',
            WeightLimitReached: 'u64',
            Barrier: 'Null',
            WeightNotComputable: 'Null'
        }
    },
    /**
     * Lookup71: xcm::v2::Xcm<Call>
     **/
    XcmV2Xcm: 'Vec<XcmV2Instruction>',
    /**
     * Lookup73: xcm::v2::Instruction<Call>
     **/
    XcmV2Instruction: {
        _enum: {
            WithdrawAsset: 'XcmV1MultiassetMultiAssets',
            ReserveAssetDeposited: 'XcmV1MultiassetMultiAssets',
            ReceiveTeleportedAsset: 'XcmV1MultiassetMultiAssets',
            QueryResponse: {
                queryId: 'Compact<u64>',
                response: 'XcmV2Response',
                maxWeight: 'Compact<u64>',
            },
            TransferAsset: {
                assets: 'XcmV1MultiassetMultiAssets',
                beneficiary: 'XcmV1MultiLocation',
            },
            TransferReserveAsset: {
                assets: 'XcmV1MultiassetMultiAssets',
                dest: 'XcmV1MultiLocation',
                xcm: 'XcmV2Xcm',
            },
            Transact: {
                originType: 'XcmV0OriginKind',
                requireWeightAtMost: 'Compact<u64>',
                call: 'XcmDoubleEncoded',
            },
            HrmpNewChannelOpenRequest: {
                sender: 'Compact<u32>',
                maxMessageSize: 'Compact<u32>',
                maxCapacity: 'Compact<u32>',
            },
            HrmpChannelAccepted: {
                recipient: 'Compact<u32>',
            },
            HrmpChannelClosing: {
                initiator: 'Compact<u32>',
                sender: 'Compact<u32>',
                recipient: 'Compact<u32>',
            },
            ClearOrigin: 'Null',
            DescendOrigin: 'XcmV1MultilocationJunctions',
            ReportError: {
                queryId: 'Compact<u64>',
                dest: 'XcmV1MultiLocation',
                maxResponseWeight: 'Compact<u64>',
            },
            DepositAsset: {
                assets: 'XcmV1MultiassetMultiAssetFilter',
                maxAssets: 'Compact<u32>',
                beneficiary: 'XcmV1MultiLocation',
            },
            DepositReserveAsset: {
                assets: 'XcmV1MultiassetMultiAssetFilter',
                maxAssets: 'Compact<u32>',
                dest: 'XcmV1MultiLocation',
                xcm: 'XcmV2Xcm',
            },
            ExchangeAsset: {
                give: 'XcmV1MultiassetMultiAssetFilter',
                receive: 'XcmV1MultiassetMultiAssets',
            },
            InitiateReserveWithdraw: {
                assets: 'XcmV1MultiassetMultiAssetFilter',
                reserve: 'XcmV1MultiLocation',
                xcm: 'XcmV2Xcm',
            },
            InitiateTeleport: {
                assets: 'XcmV1MultiassetMultiAssetFilter',
                dest: 'XcmV1MultiLocation',
                xcm: 'XcmV2Xcm',
            },
            QueryHolding: {
                queryId: 'Compact<u64>',
                dest: 'XcmV1MultiLocation',
                assets: 'XcmV1MultiassetMultiAssetFilter',
                maxResponseWeight: 'Compact<u64>',
            },
            BuyExecution: {
                fees: 'XcmV1MultiAsset',
                weightLimit: 'XcmV2WeightLimit',
            },
            RefundSurplus: 'Null',
            SetErrorHandler: 'XcmV2Xcm',
            SetAppendix: 'XcmV2Xcm',
            ClearError: 'Null',
            ClaimAsset: {
                assets: 'XcmV1MultiassetMultiAssets',
                ticket: 'XcmV1MultiLocation',
            },
            Trap: 'Compact<u64>',
            SubscribeVersion: {
                queryId: 'Compact<u64>',
                maxResponseWeight: 'Compact<u64>',
            },
            UnsubscribeVersion: 'Null'
        }
    },
    /**
     * Lookup74: xcm::v1::multiasset::MultiAssets
     **/
    XcmV1MultiassetMultiAssets: 'Vec<XcmV1MultiAsset>',
    /**
     * Lookup76: xcm::v1::multiasset::MultiAsset
     **/
    XcmV1MultiAsset: {
        id: 'XcmV1MultiassetAssetId',
        fun: 'XcmV1MultiassetFungibility'
    },
    /**
     * Lookup77: xcm::v1::multiasset::AssetId
     **/
    XcmV1MultiassetAssetId: {
        _enum: {
            Concrete: 'XcmV1MultiLocation',
            Abstract: 'Bytes'
        }
    },
    /**
     * Lookup78: xcm::v1::multiasset::Fungibility
     **/
    XcmV1MultiassetFungibility: {
        _enum: {
            Fungible: 'Compact<u128>',
            NonFungible: 'XcmV1MultiassetAssetInstance'
        }
    },
    /**
     * Lookup79: xcm::v1::multiasset::AssetInstance
     **/
    XcmV1MultiassetAssetInstance: {
        _enum: {
            Undefined: 'Null',
            Index: 'Compact<u128>',
            Array4: '[u8;4]',
            Array8: '[u8;8]',
            Array16: '[u8;16]',
            Array32: '[u8;32]',
            Blob: 'Bytes'
        }
    },
    /**
     * Lookup82: xcm::v2::Response
     **/
    XcmV2Response: {
        _enum: {
            Null: 'Null',
            Assets: 'XcmV1MultiassetMultiAssets',
            ExecutionResult: 'Option<(u32,XcmV2TraitsError)>',
            Version: 'u32'
        }
    },
    /**
     * Lookup85: xcm::v0::OriginKind
     **/
    XcmV0OriginKind: {
        _enum: ['Native', 'SovereignAccount', 'Superuser', 'Xcm']
    },
    /**
     * Lookup86: xcm::double_encoded::DoubleEncoded<T>
     **/
    XcmDoubleEncoded: {
        encoded: 'Bytes'
    },
    /**
     * Lookup87: xcm::v1::multiasset::MultiAssetFilter
     **/
    XcmV1MultiassetMultiAssetFilter: {
        _enum: {
            Definite: 'XcmV1MultiassetMultiAssets',
            Wild: 'XcmV1MultiassetWildMultiAsset'
        }
    },
    /**
     * Lookup88: xcm::v1::multiasset::WildMultiAsset
     **/
    XcmV1MultiassetWildMultiAsset: {
        _enum: {
            All: 'Null',
            AllOf: {
                id: 'XcmV1MultiassetAssetId',
                fun: 'XcmV1MultiassetWildFungibility'
            }
        }
    },
    /**
     * Lookup89: xcm::v1::multiasset::WildFungibility
     **/
    XcmV1MultiassetWildFungibility: {
        _enum: ['Fungible', 'NonFungible']
    },
    /**
     * Lookup90: xcm::v2::WeightLimit
     **/
    XcmV2WeightLimit: {
        _enum: {
            Unlimited: 'Null',
            Limited: 'Compact<u64>'
        }
    },
    /**
     * Lookup92: xcm::VersionedMultiAssets
     **/
    XcmVersionedMultiAssets: {
        _enum: {
            V0: 'Vec<XcmV0MultiAsset>',
            V1: 'XcmV1MultiassetMultiAssets'
        }
    },
    /**
     * Lookup94: xcm::v0::multi_asset::MultiAsset
     **/
    XcmV0MultiAsset: {
        _enum: {
            None: 'Null',
            All: 'Null',
            AllFungible: 'Null',
            AllNonFungible: 'Null',
            AllAbstractFungible: {
                id: 'Bytes',
            },
            AllAbstractNonFungible: {
                class: 'Bytes',
            },
            AllConcreteFungible: {
                id: 'XcmV0MultiLocation',
            },
            AllConcreteNonFungible: {
                class: 'XcmV0MultiLocation',
            },
            AbstractFungible: {
                id: 'Bytes',
                amount: 'Compact<u128>',
            },
            AbstractNonFungible: {
                class: 'Bytes',
                instance: 'XcmV1MultiassetAssetInstance',
            },
            ConcreteFungible: {
                id: 'XcmV0MultiLocation',
                amount: 'Compact<u128>',
            },
            ConcreteNonFungible: {
                class: 'XcmV0MultiLocation',
                instance: 'XcmV1MultiassetAssetInstance'
            }
        }
    },
    /**
     * Lookup95: xcm::v0::multi_location::MultiLocation
     **/
    XcmV0MultiLocation: {
        _enum: {
            Null: 'Null',
            X1: 'XcmV0Junction',
            X2: '(XcmV0Junction,XcmV0Junction)',
            X3: '(XcmV0Junction,XcmV0Junction,XcmV0Junction)',
            X4: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
            X5: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
            X6: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
            X7: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)',
            X8: '(XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction,XcmV0Junction)'
        }
    },
    /**
     * Lookup96: xcm::v0::junction::Junction
     **/
    XcmV0Junction: {
        _enum: {
            Parent: 'Null',
            Parachain: 'Compact<u32>',
            AccountId32: {
                network: 'XcmV0JunctionNetworkId',
                id: '[u8;32]',
            },
            AccountIndex64: {
                network: 'XcmV0JunctionNetworkId',
                index: 'Compact<u64>',
            },
            AccountKey20: {
                network: 'XcmV0JunctionNetworkId',
                key: '[u8;20]',
            },
            PalletInstance: 'u8',
            GeneralIndex: 'Compact<u128>',
            GeneralKey: 'Bytes',
            OnlyChild: 'Null',
            Plurality: {
                id: 'XcmV0JunctionBodyId',
                part: 'XcmV0JunctionBodyPart'
            }
        }
    },
    /**
     * Lookup97: xcm::VersionedMultiLocation
     **/
    XcmVersionedMultiLocation: {
        _enum: {
            V0: 'XcmV0MultiLocation',
            V1: 'XcmV1MultiLocation'
        }
    },
    /**
     * Lookup98: cumulus_pallet_dmp_queue::pallet::Event<T>
     **/
    CumulusPalletDmpQueueEvent: {
        _enum: {
            InvalidFormat: '[u8;32]',
            UnsupportedVersion: '[u8;32]',
            ExecutedDownward: '([u8;32],XcmV2TraitsOutcome)',
            WeightExhausted: '([u8;32],u64,u64)',
            OverweightEnqueued: '([u8;32],u64,u64)',
            OverweightServiced: '(u64,u64)'
        }
    },
    /**
     * Lookup99: cumulus_pallet_xcmp_queue::pallet::Event<T>
     **/
    CumulusPalletXcmpQueueEvent: {
        _enum: {
            Success: 'Option<H256>',
            Fail: '(Option<H256>,XcmV2TraitsError)',
            BadVersion: 'Option<H256>',
            BadFormat: 'Option<H256>',
            UpwardMessageSent: 'Option<H256>',
            XcmpMessageSent: 'Option<H256>',
            OverweightEnqueued: '(u32,u32,u64,u64)',
            OverweightServiced: '(u64,u64)'
        }
    },
    /**
     * Lookup102: frame_system::Phase
     **/
    FrameSystemPhase: {
        _enum: {
            ApplyExtrinsic: 'u32',
            Finalization: 'Null',
            Initialization: 'Null'
        }
    },
    /**
     * Lookup106: frame_system::LastRuntimeUpgradeInfo
     **/
    FrameSystemLastRuntimeUpgradeInfo: {
        specVersion: 'Compact<u32>',
        specName: 'Text'
    },
    /**
     * Lookup108: frame_system::pallet::Call<T>
     **/
    FrameSystemCall: {
        _enum: {
            fill_block: {
                ratio: 'Perbill',
            },
            remark: {
                remark: 'Bytes',
            },
            set_heap_pages: {
                pages: 'u64',
            },
            set_code: {
                code: 'Bytes',
            },
            set_code_without_checks: {
                code: 'Bytes',
            },
            set_storage: {
                items: 'Vec<(Bytes,Bytes)>',
            },
            kill_storage: {
                _alias: {
                    keys_: 'keys',
                },
                keys_: 'Vec<Bytes>',
            },
            kill_prefix: {
                prefix: 'Bytes',
                subkeys: 'u32',
            },
            remark_with_event: {
                remark: 'Bytes'
            }
        }
    },
    /**
     * Lookup113: frame_system::limits::BlockWeights
     **/
    FrameSystemLimitsBlockWeights: {
        baseBlock: 'u64',
        maxBlock: 'u64',
        perClass: 'FrameSupportWeightsPerDispatchClassWeightsPerClass'
    },
    /**
     * Lookup114: frame_support::weights::PerDispatchClass<frame_system::limits::WeightsPerClass>
     **/
    FrameSupportWeightsPerDispatchClassWeightsPerClass: {
        normal: 'FrameSystemLimitsWeightsPerClass',
        operational: 'FrameSystemLimitsWeightsPerClass',
        mandatory: 'FrameSystemLimitsWeightsPerClass'
    },
    /**
     * Lookup115: frame_system::limits::WeightsPerClass
     **/
    FrameSystemLimitsWeightsPerClass: {
        baseExtrinsic: 'u64',
        maxExtrinsic: 'Option<u64>',
        maxTotal: 'Option<u64>',
        reserved: 'Option<u64>'
    },
    /**
     * Lookup117: frame_system::limits::BlockLength
     **/
    FrameSystemLimitsBlockLength: {
        max: 'FrameSupportWeightsPerDispatchClassU32'
    },
    /**
     * Lookup118: frame_support::weights::PerDispatchClass<T>
     **/
    FrameSupportWeightsPerDispatchClassU32: {
        normal: 'u32',
        operational: 'u32',
        mandatory: 'u32'
    },
    /**
     * Lookup119: frame_support::weights::RuntimeDbWeight
     **/
    FrameSupportWeightsRuntimeDbWeight: {
        read: 'u64',
        write: 'u64'
    },
    /**
     * Lookup120: sp_version::RuntimeVersion
     **/
    SpVersionRuntimeVersion: {
        specName: 'Text',
        implName: 'Text',
        authoringVersion: 'u32',
        specVersion: 'u32',
        implVersion: 'u32',
        apis: 'Vec<([u8;8],u32)>',
        transactionVersion: 'u32',
        stateVersion: 'u8'
    },
    /**
     * Lookup124: frame_system::pallet::Error<T>
     **/
    FrameSystemError: {
        _enum: ['InvalidSpecName', 'SpecVersionNeedsToIncrease', 'FailedToExtractRuntimeVersion', 'NonDefaultComposite', 'NonZeroRefCount', 'CallFiltered']
    },
    /**
     * Lookup125: polkadot_primitives::v1::PersistedValidationData<primitive_types::H256, N>
     **/
    PolkadotPrimitivesV1PersistedValidationData: {
        parentHead: 'Bytes',
        relayParentNumber: 'u32',
        relayParentStorageRoot: 'H256',
        maxPovSize: 'u32'
    },
    /**
     * Lookup128: polkadot_primitives::v1::UpgradeRestriction
     **/
    PolkadotPrimitivesV1UpgradeRestriction: {
        _enum: ['Present']
    },
    /**
     * Lookup129: sp_trie::storage_proof::StorageProof
     **/
    SpTrieStorageProof: {
        trieNodes: 'BTreeSet<Bytes>'
    },
    /**
     * Lookup131: cumulus_pallet_parachain_system::relay_state_snapshot::MessagingStateSnapshot
     **/
    CumulusPalletParachainSystemRelayStateSnapshotMessagingStateSnapshot: {
        dmqMqcHead: 'H256',
        relayDispatchQueueSize: '(u32,u32)',
        ingressChannels: 'Vec<(u32,PolkadotPrimitivesV1AbridgedHrmpChannel)>',
        egressChannels: 'Vec<(u32,PolkadotPrimitivesV1AbridgedHrmpChannel)>'
    },
    /**
     * Lookup134: polkadot_primitives::v1::AbridgedHrmpChannel
     **/
    PolkadotPrimitivesV1AbridgedHrmpChannel: {
        maxCapacity: 'u32',
        maxTotalSize: 'u32',
        maxMessageSize: 'u32',
        msgCount: 'u32',
        totalSize: 'u32',
        mqcHead: 'Option<H256>'
    },
    /**
     * Lookup135: polkadot_primitives::v1::AbridgedHostConfiguration
     **/
    PolkadotPrimitivesV1AbridgedHostConfiguration: {
        maxCodeSize: 'u32',
        maxHeadDataSize: 'u32',
        maxUpwardQueueCount: 'u32',
        maxUpwardQueueSize: 'u32',
        maxUpwardMessageSize: 'u32',
        maxUpwardMessageNumPerCandidate: 'u32',
        hrmpMaxMessageNumPerCandidate: 'u32',
        validationUpgradeCooldown: 'u32',
        validationUpgradeDelay: 'u32'
    },
    /**
     * Lookup141: polkadot_core_primitives::OutboundHrmpMessage<polkadot_parachain::primitives::Id>
     **/
    PolkadotCorePrimitivesOutboundHrmpMessage: {
        recipient: 'u32',
        data: 'Bytes'
    },
    /**
     * Lookup142: cumulus_pallet_parachain_system::pallet::Call<T>
     **/
    CumulusPalletParachainSystemCall: {
        _enum: {
            set_validation_data: {
                data: 'CumulusPrimitivesParachainInherentParachainInherentData',
            },
            sudo_send_upward_message: {
                message: 'Bytes',
            },
            authorize_upgrade: {
                codeHash: 'H256',
            },
            enact_authorized_upgrade: {
                code: 'Bytes'
            }
        }
    },
    /**
     * Lookup143: cumulus_primitives_parachain_inherent::ParachainInherentData
     **/
    CumulusPrimitivesParachainInherentParachainInherentData: {
        validationData: 'PolkadotPrimitivesV1PersistedValidationData',
        relayChainState: 'SpTrieStorageProof',
        downwardMessages: 'Vec<PolkadotCorePrimitivesInboundDownwardMessage>',
        horizontalMessages: 'BTreeMap<u32, Vec<PolkadotCorePrimitivesInboundHrmpMessage>>'
    },
    /**
     * Lookup145: polkadot_core_primitives::InboundDownwardMessage<BlockNumber>
     **/
    PolkadotCorePrimitivesInboundDownwardMessage: {
        sentAt: 'u32',
        msg: 'Bytes'
    },
    /**
     * Lookup148: polkadot_core_primitives::InboundHrmpMessage<BlockNumber>
     **/
    PolkadotCorePrimitivesInboundHrmpMessage: {
        sentAt: 'u32',
        data: 'Bytes'
    },
    /**
     * Lookup151: cumulus_pallet_parachain_system::pallet::Error<T>
     **/
    CumulusPalletParachainSystemError: {
        _enum: ['OverlappingUpgrades', 'ProhibitedByPolkadot', 'TooBig', 'ValidationDataNotAvailable', 'HostConfigurationNotAvailable', 'NotScheduled', 'NothingAuthorized', 'Unauthorized']
    },
    /**
     * Lookup152: pallet_utility::pallet::Call<T>
     **/
    PalletUtilityCall: {
        _enum: {
            batch: {
                calls: 'Vec<Call>',
            },
            as_derivative: {
                index: 'u16',
                call: 'Call',
            },
            batch_all: {
                calls: 'Vec<Call>',
            },
            dispatch_as: {
                asOrigin: 'EqNodeRuntimeOriginCaller',
                call: 'Call'
            }
        }
    },
    /**
     * Lookup155: pallet_timestamp::pallet::Call<T>
     **/
    PalletTimestampCall: {
        _enum: {
            set: {
                now: 'Compact<u64>'
            }
        }
    },
    /**
     * Lookup156: eq_session_manager::pallet::Call<T>
     **/
    EqSessionManagerCall: {
        _enum: {
            add_validator: {
                validatorId: 'AccountId32',
            },
            remove_validator: {
                validatorId: 'AccountId32'
            }
        }
    },
    /**
     * Lookup157: pallet_authorship::pallet::Call<T>
     **/
    PalletAuthorshipCall: {
        _enum: {
            set_uncles: {
                newUncles: 'Vec<SpRuntimeHeader>'
            }
        }
    },
    /**
     * Lookup159: sp_runtime::generic::header::Header<Number, sp_runtime::traits::BlakeTwo256>
     **/
    SpRuntimeHeader: {
        parentHash: 'H256',
        number: 'Compact<u32>',
        stateRoot: 'H256',
        extrinsicsRoot: 'H256',
        digest: 'SpRuntimeDigest'
    },
    /**
     * Lookup160: sp_runtime::traits::BlakeTwo256
     **/
    SpRuntimeBlakeTwo256: 'Null',
    /**
     * Lookup161: pallet_session::pallet::Call<T>
     **/
    PalletSessionCall: {
        _enum: {
            set_keys: {
                _alias: {
                    keys_: 'keys',
                },
                keys_: 'EqNodeRuntimeOpaqueSessionKeys',
                proof: 'Bytes',
            },
            purge_keys: 'Null'
        }
    },
    /**
     * Lookup162: eq_node_runtime::opaque::SessionKeys
     **/
    EqNodeRuntimeOpaqueSessionKeys: {
        aura: 'SpConsensusAuraSr25519AppSr25519Public',
        eqRate: 'EqRateEd25519AppEd25519Public'
    },
    /**
     * Lookup163: sp_consensus_aura::sr25519::app_sr25519::Public
     **/
    SpConsensusAuraSr25519AppSr25519Public: 'SpCoreSr25519Public',
    /**
     * Lookup164: sp_core::sr25519::Public
     **/
    SpCoreSr25519Public: '[u8;32]',
    /**
     * Lookup165: eq_rate::ed25519::app_ed25519::Public
     **/
    EqRateEd25519AppEd25519Public: 'SpCoreEd25519Public',
    /**
     * Lookup166: sp_core::ed25519::Public
     **/
    SpCoreEd25519Public: '[u8;32]',
    /**
     * Lookup167: eq_assets::pallet::Call<T>
     **/
    EqAssetsCall: {
        _enum: {
            add_asset: {
                assetName: 'Bytes',
                lot: 'u128',
                priceStep: 'u128',
                makerFee: 'u128',
                takerFee: 'u128',
                assetXcmData: 'Option<EqPrimitivesAssetAssetXcmData>',
                debtWeight: 'u128',
                buyoutPriority: 'u64',
                assetType: 'EqPrimitivesAssetAssetType',
                isDexEnabled: 'bool',
                collateralEnabled: 'bool',
                prices: 'Vec<i64>',
            },
            remove_asset: {
                assetId: 'u64',
            },
            update_asset: {
                assetId: 'u64',
                lot: 'Option<u128>',
                priceStep: 'Option<u128>',
                makerFee: 'Option<u128>',
                takerFee: 'Option<u128>',
                assetXcmData: 'Option<EqAssetsEqOption>',
                debtWeight: 'Option<u128>',
                buyoutPriority: 'Option<u64>',
                assetType: 'Option<EqPrimitivesAssetAssetType>',
                isDexEnabled: 'Option<bool>',
                collateralEnabled: 'Option<bool>'
            }
        }
    },
    /**
     * Lookup169: eq_primitives::asset::AssetXcmData
     **/
    EqPrimitivesAssetAssetXcmData: {
        multiLocation: 'XcmV1MultiLocation',
        decimals: 'u8'
    },
    /**
     * Lookup170: eq_primitives::asset::AssetType
     **/
    EqPrimitivesAssetAssetType: {
        _enum: {
            Native: 'Null',
            Physical: 'Null',
            Synthetic: 'Null',
            Lp: 'EqPrimitivesAssetAmmPool'
        }
    },
    /**
     * Lookup171: eq_primitives::asset::AmmPool
     **/
    EqPrimitivesAssetAmmPool: {
        _enum: {
            Curve: 'u32',
            Yield: 'u32'
        }
    },
    /**
     * Lookup177: eq_assets::EqOption<eq_primitives::asset::AssetXcmData>
     **/
    EqAssetsEqOption: {
        _enum: {
            None: 'Null',
            Some: 'EqPrimitivesAssetAssetXcmData'
        }
    },
    /**
     * Lookup180: eq_distribution::pallet::Call<T, I>
     **/
    EqDistributionCall: {
        _enum: {
            transfer: {
                asset: 'u64',
                target: 'AccountId32',
                value: 'u128',
            },
            set_manager: {
                who: 'AccountId32',
            },
            vested_transfer: {
                target: 'AccountId32',
                schedule: '(u128,u128,u32)'
            }
        }
    },
    /**
     * Lookup182: eq_treasury::pallet::Call<T>
     **/
    EqTreasuryCall: {
        _enum: {
            colaterall_buyout: {
                asset: 'u64',
                amount: 'u128',
                maxPrice: 'u128'
            }
        }
    },
    /**
     * Lookup184: eq_balances::pallet::Call<T>
     **/
    EqBalancesCall: {
        _enum: {
            transfer: {
                asset: 'u64',
                to: 'AccountId32',
                value: 'u128',
            },
            deposit: {
                asset: 'u64',
                to: 'AccountId32',
                value: 'u128',
            },
            burn: {
                asset: 'u64',
                from: 'AccountId32',
                value: 'u128',
            },
            enable_transfers: 'Null',
            disable_transfers: 'Null',
            xcm_toggle: {
                value: 'bool',
            },
            xcm_transfer_native: {
                from: 'AccountId32',
                asset: 'u64',
                amount: 'u128',
                to: 'EqPrimitivesAccountType',
            },
            xcm_transfer_native_signed: {
                asset: 'u64',
                amount: 'u128',
                to: 'EqPrimitivesAccountType',
            },
            xcm_transfer: {
                from: 'AccountId32',
                asset: 'u64',
                amount: 'u128',
                to: 'XcmV1MultiLocation',
            },
            xcm_transfer_signed: {
                asset: 'u64',
                amount: 'u128',
                to: 'XcmV1MultiLocation'
            }
        }
    },
    /**
     * Lookup185: eq_primitives::AccountType
     **/
    EqPrimitivesAccountType: {
        _enum: {
            Id32: '[u8;32]',
            Key20: '[u8;20]'
        }
    },
    /**
     * Lookup186: pallet_sudo::pallet::Call<T>
     **/
    PalletSudoCall: {
        _enum: {
            sudo: {
                call: 'Call',
            },
            sudo_unchecked_weight: {
                call: 'Call',
                weight: 'u64',
            },
            set_key: {
                _alias: {
                    new_: 'new',
                },
                new_: 'MultiAddress',
            },
            sudo_as: {
                who: 'MultiAddress',
                call: 'Call'
            }
        }
    },
    /**
     * Lookup189: eq_whitelists::pallet::Call<T>
     **/
    EqWhitelistsCall: {
        _enum: {
            add_to_whitelist: {
                whoToAdd: 'AccountId32',
            },
            remove_from_whitelist: {
                whoToRemove: 'AccountId32'
            }
        }
    },
    /**
     * Lookup190: eq_rate::pallet::Call<T>
     **/
    EqRateCall: {
        _enum: {
            reinit: {
                request: 'EqRateOperationRequest',
                signature: 'EqRateEd25519AppEd25519Signature',
            },
            reinit_bailsman: {
                request: 'EqRateOperationRequest',
                signature: 'EqRateEd25519AppEd25519Signature',
            },
            delete_account: {
                request: 'EqRateOperationRequest',
                signature: 'EqRateEd25519AppEd25519Signature',
            },
            delete_account_external: {
                account: 'AccountId32',
            },
            reinit_external: {
                owner: 'AccountId32',
            },
            set_now_millis_offset: {
                offset: 'u64',
            },
            set_auto_reinit_enabled: {
                enabled: 'bool'
            }
        }
    },
    /**
     * Lookup191: eq_rate::OperationRequest<sp_core::crypto::AccountId32, BlockNumber>
     **/
    EqRateOperationRequest: {
        account: 'Option<AccountId32>',
        authorityIndex: 'u32',
        validatorsLen: 'u32',
        blockNum: 'u32',
        higherPriority: 'bool'
    },
    /**
     * Lookup192: eq_rate::ed25519::app_ed25519::Signature
     **/
    EqRateEd25519AppEd25519Signature: 'SpCoreEd25519Signature',
    /**
     * Lookup193: sp_core::ed25519::Signature
     **/
    SpCoreEd25519Signature: '[u8;64]',
    /**
     * Lookup198: eq_vesting::pallet::Call<T, I>
     **/
    EqVestingCall: {
        _enum: {
            vest: 'Null',
            vest_other: {
                target: 'MultiAddress',
            },
            force_vested_transfer: {
                source: 'MultiAddress',
                target: 'MultiAddress',
                schedule: 'EqVestingVestingInfo'
            }
        }
    },
    /**
     * Lookup199: eq_vesting::VestingInfo<Balance, BlockNumber>
     **/
    EqVestingVestingInfo: {
        locked: 'u128',
        perBlock: 'u128',
        startingBlock: 'u32'
    },
    /**
     * Lookup201: eq_claim::pallet::Call<T>
     **/
    EqClaimCall: {
        _enum: {
            claim: {
                dest: 'AccountId32',
                ethereumSignature: 'EqClaimEcdsaSignature',
            },
            mint_claim: {
                who: 'EqClaimEthereumAddress',
                value: 'u128',
                vestingSchedule: 'Option<(u128,u128,u32)>',
                statement: 'bool',
            },
            claim_attest: {
                dest: 'AccountId32',
                ethereumSignature: 'EqClaimEcdsaSignature',
                statement: 'Bytes',
            },
            attest: {
                statement: 'Bytes',
            },
            move_claim: {
                _alias: {
                    new_: 'new',
                },
                old: 'EqClaimEthereumAddress',
                new_: 'EqClaimEthereumAddress',
                maybePreclaim: 'Option<AccountId32>'
            }
        }
    },
    /**
     * Lookup202: eq_claim::EcdsaSignature
     **/
    EqClaimEcdsaSignature: '[u8;65]',
    /**
     * Lookup205: eq_subaccounts::pallet::Call<T>
     **/
    EqSubaccountsCall: {
        _enum: {
            transfer_to_subaccount: {
                subaccType: 'EqPrimitivesSubaccountSubAccType',
                asset: 'u64',
                value: 'u128',
            },
            transfer_from_subaccount: {
                subaccType: 'EqPrimitivesSubaccountSubAccType',
                asset: 'u64',
                amount: 'u128',
            },
            transfer: {
                subaccType: 'EqPrimitivesSubaccountSubAccType',
                destination: 'AccountId32',
                asset: 'u64',
                amount: 'u128'
            }
        }
    },
    /**
     * Lookup206: financial_pallet::Call<T>
     **/
    FinancialPalletCall: {
        _enum: {
            recalc_asset: {
                asset: 'u64',
            },
            recalc_portfolio: {
                accountId: 'AccountId32',
                zScore: 'u32',
            },
            recalc: 'Null',
            set_metrics: {
                metrics: 'FinancialPalletFinancialMetrics',
            },
            set_per_asset_metrics: {
                asset: 'u64',
                metrics: 'FinancialPalletAssetMetrics'
            }
        }
    },
    /**
     * Lookup207: financial_pallet::FinancialMetrics<eq_primitives::asset::Asset, substrate_fixed::FixedI128<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UTerm, typenum::bit::B1>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>>>
     **/
    FinancialPalletFinancialMetrics: {
        periodStart: 'FinancialPalletDuration',
        periodEnd: 'FinancialPalletDuration',
        assets: 'Vec<u64>',
        meanReturns: 'Vec<SubstrateFixedFixedI128>',
        volatilities: 'Vec<SubstrateFixedFixedI128>',
        correlations: 'Vec<SubstrateFixedFixedI128>',
        covariances: 'Vec<SubstrateFixedFixedI128>'
    },
    /**
     * Lookup208: substrate_fixed::FixedI128<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UTerm, typenum::bit::B1>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>>
     **/
    SubstrateFixedFixedI128: {
        bits: 'i128'
    },
    /**
     * Lookup216: typenum::uint::UTerm
     **/
    TypenumUintUTerm: 'Null',
    /**
     * Lookup217: typenum::bit::B1
     **/
    TypenumBitB1: 'Null',
    /**
     * Lookup218: typenum::bit::B0
     **/
    TypenumBitB0: 'Null',
    /**
     * Lookup220: financial_pallet::Duration
     **/
    FinancialPalletDuration: {
        secs: 'u64',
        nanos: 'u32'
    },
    /**
     * Lookup223: financial_pallet::AssetMetrics<eq_primitives::asset::Asset, substrate_fixed::FixedI128<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UTerm, typenum::bit::B1>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>>>
     **/
    FinancialPalletAssetMetrics: {
        periodStart: 'FinancialPalletDuration',
        periodEnd: 'FinancialPalletDuration',
        returns: 'Vec<SubstrateFixedFixedI128>',
        volatility: 'SubstrateFixedFixedI128',
        correlations: 'Vec<(u64,SubstrateFixedFixedI128)>'
    },
    /**
     * Lookup226: chainbridge::pallet::Call<T>
     **/
    ChainbridgeCall: {
        _enum: {
            set_threshold: {
                threshold: 'u32',
            },
            set_fee: {
                chainId: 'u8',
                fee: 'u128',
            },
            set_proposal_lifetime: {
                lifetime: 'u32',
            },
            toggle_chain: {
                chainId: 'u8',
                enabled: 'bool',
            },
            set_resource: {
                id: '[u8;32]',
                method: 'Bytes',
            },
            remove_resource: {
                id: '[u8;32]',
            },
            whitelist_chain: {
                id: 'u8',
                fee: 'u128',
            },
            add_relayer: {
                v: 'AccountId32',
            },
            remove_relayer: {
                v: 'AccountId32',
            },
            acknowledge_proposal: {
                nonce: 'u64',
                srcId: 'u8',
                rId: '[u8;32]',
                call: 'Call',
            },
            reject_proposal: {
                nonce: 'u64',
                srcId: 'u8',
                rId: '[u8;32]',
                call: 'Call',
            },
            eval_vote_state: {
                nonce: 'u64',
                srcId: 'u8',
                prop: 'Call',
            },
            redistribute_fees: 'Null'
        }
    },
    /**
     * Lookup227: eq_bridge::pallet::Call<T>
     **/
    EqBridgeCall: {
        _enum: {
            transfer_native: {
                amount: 'u128',
                recipient: 'Bytes',
                destId: 'u8',
                resourceId: '[u8;32]',
            },
            set_resource: {
                id: '[u8;32]',
                asset: 'u64',
            },
            set_minimum_transfer_amount: {
                destId: 'u8',
                resourceId: '[u8;32]',
                minimumAmount: 'u128',
            },
            transfer: {
                to: 'AccountId32',
                amount: 'u128',
                resourceId: '[u8;32]',
            },
            xcm_transfer: {
                to: 'Bytes',
                amount: 'u128',
                resourceId: '[u8;32]',
            },
            remark: {
                _alias: {
                    hash_: 'hash',
                },
                hash_: 'H256'
            }
        }
    },
    /**
     * Lookup228: eq_multisig_sudo::pallet::Call<T>
     **/
    EqMultisigSudoCall: {
        _enum: {
            add_key: {
                key: 'AccountId32',
            },
            remove_key: {
                key: 'AccountId32',
            },
            modify_threshold: {
                newValue: 'u32',
            },
            propose: {
                call: 'Call',
            },
            approve: {
                callHash: '[u8;32]',
            },
            cancel_proposal: {
                callHash: '[u8;32]'
            }
        }
    },
    /**
     * Lookup229: eq_lockdrop::pallet::Call<T>
     **/
    EqLockdropCall: {
        _enum: {
            lock: {
                amount: 'u128',
            },
            unlock_external: 'Null',
            unlock: {
                request: 'EqLockdropOperationRequest',
                signature: 'EqRateEd25519AppEd25519Signature',
            },
            set_lock_start: {
                timestamp: 'u64',
            },
            clear_lock_start: 'Null',
            set_auto_unlock: {
                enabled: 'bool'
            }
        }
    },
    /**
     * Lookup230: eq_lockdrop::OperationRequest<sp_core::crypto::AccountId32, BlockNumber>
     **/
    EqLockdropOperationRequest: {
        account: 'AccountId32',
        authorityIndex: 'u32',
        validatorsLen: 'u32',
        blockNum: 'u32'
    },
    /**
     * Lookup231: pallet_multisig::pallet::Call<T>
     **/
    PalletMultisigCall: {
        _enum: {
            as_multi_threshold_1: {
                otherSignatories: 'Vec<AccountId32>',
                call: 'Call',
            },
            as_multi: {
                threshold: 'u16',
                otherSignatories: 'Vec<AccountId32>',
                maybeTimepoint: 'Option<PalletMultisigTimepoint>',
                call: 'WrapperKeepOpaque<Call>',
                storeCall: 'bool',
                maxWeight: 'u64',
            },
            approve_as_multi: {
                threshold: 'u16',
                otherSignatories: 'Vec<AccountId32>',
                maybeTimepoint: 'Option<PalletMultisigTimepoint>',
                callHash: '[u8;32]',
                maxWeight: 'u64',
            },
            cancel_as_multi: {
                threshold: 'u16',
                otherSignatories: 'Vec<AccountId32>',
                timepoint: 'PalletMultisigTimepoint',
                callHash: '[u8;32]'
            }
        }
    },
    /**
     * Lookup235: pallet_proxy::pallet::Call<T>
     **/
    PalletProxyCall: {
        _enum: {
            proxy: {
                real: 'AccountId32',
                forceProxyType: 'Option<EqPrimitivesProxyProxyType>',
                call: 'Call',
            },
            add_proxy: {
                delegate: 'AccountId32',
                proxyType: 'EqPrimitivesProxyProxyType',
                delay: 'u32',
            },
            remove_proxy: {
                delegate: 'AccountId32',
                proxyType: 'EqPrimitivesProxyProxyType',
                delay: 'u32',
            },
            remove_proxies: 'Null',
            anonymous: {
                proxyType: 'EqPrimitivesProxyProxyType',
                delay: 'u32',
                index: 'u16',
            },
            kill_anonymous: {
                spawner: 'AccountId32',
                proxyType: 'EqPrimitivesProxyProxyType',
                index: 'u16',
                height: 'Compact<u32>',
                extIndex: 'Compact<u32>',
            },
            announce: {
                real: 'AccountId32',
                callHash: 'H256',
            },
            remove_announcement: {
                real: 'AccountId32',
                callHash: 'H256',
            },
            reject_announcement: {
                delegate: 'AccountId32',
                callHash: 'H256',
            },
            proxy_announced: {
                delegate: 'AccountId32',
                real: 'AccountId32',
                forceProxyType: 'Option<EqPrimitivesProxyProxyType>',
                call: 'Call'
            }
        }
    },
    /**
     * Lookup237: eq_migration::pallet::Call<T>
     **/
    EqMigrationCall: {
        _enum: {
            set_migration: {
                migration: 'Vec<(Bytes,Bytes)>'
            }
        }
    },
    /**
     * Lookup238: pallet_xcm::pallet::Call<T>
     **/
    PalletXcmCall: {
        _enum: {
            send: {
                dest: 'XcmVersionedMultiLocation',
                message: 'XcmVersionedXcm',
            },
            teleport_assets: {
                dest: 'XcmVersionedMultiLocation',
                beneficiary: 'XcmVersionedMultiLocation',
                assets: 'XcmVersionedMultiAssets',
                feeAssetItem: 'u32',
            },
            reserve_transfer_assets: {
                dest: 'XcmVersionedMultiLocation',
                beneficiary: 'XcmVersionedMultiLocation',
                assets: 'XcmVersionedMultiAssets',
                feeAssetItem: 'u32',
            },
            execute: {
                message: 'XcmVersionedXcm',
                maxWeight: 'u64',
            },
            force_xcm_version: {
                location: 'XcmV1MultiLocation',
                xcmVersion: 'u32',
            },
            force_default_xcm_version: {
                maybeXcmVersion: 'Option<u32>',
            },
            force_subscribe_version_notify: {
                location: 'XcmVersionedMultiLocation',
            },
            force_unsubscribe_version_notify: {
                location: 'XcmVersionedMultiLocation',
            },
            limited_reserve_transfer_assets: {
                dest: 'XcmVersionedMultiLocation',
                beneficiary: 'XcmVersionedMultiLocation',
                assets: 'XcmVersionedMultiAssets',
                feeAssetItem: 'u32',
                weightLimit: 'XcmV2WeightLimit',
            },
            limited_teleport_assets: {
                dest: 'XcmVersionedMultiLocation',
                beneficiary: 'XcmVersionedMultiLocation',
                assets: 'XcmVersionedMultiAssets',
                feeAssetItem: 'u32',
                weightLimit: 'XcmV2WeightLimit'
            }
        }
    },
    /**
     * Lookup239: xcm::VersionedXcm<Call>
     **/
    XcmVersionedXcm: {
        _enum: {
            V0: 'XcmV0Xcm',
            V1: 'XcmV1Xcm',
            V2: 'XcmV2Xcm'
        }
    },
    /**
     * Lookup240: xcm::v0::Xcm<Call>
     **/
    XcmV0Xcm: {
        _enum: {
            WithdrawAsset: {
                assets: 'Vec<XcmV0MultiAsset>',
                effects: 'Vec<XcmV0Order>',
            },
            ReserveAssetDeposit: {
                assets: 'Vec<XcmV0MultiAsset>',
                effects: 'Vec<XcmV0Order>',
            },
            TeleportAsset: {
                assets: 'Vec<XcmV0MultiAsset>',
                effects: 'Vec<XcmV0Order>',
            },
            QueryResponse: {
                queryId: 'Compact<u64>',
                response: 'XcmV0Response',
            },
            TransferAsset: {
                assets: 'Vec<XcmV0MultiAsset>',
                dest: 'XcmV0MultiLocation',
            },
            TransferReserveAsset: {
                assets: 'Vec<XcmV0MultiAsset>',
                dest: 'XcmV0MultiLocation',
                effects: 'Vec<XcmV0Order>',
            },
            Transact: {
                originType: 'XcmV0OriginKind',
                requireWeightAtMost: 'u64',
                call: 'XcmDoubleEncoded',
            },
            HrmpNewChannelOpenRequest: {
                sender: 'Compact<u32>',
                maxMessageSize: 'Compact<u32>',
                maxCapacity: 'Compact<u32>',
            },
            HrmpChannelAccepted: {
                recipient: 'Compact<u32>',
            },
            HrmpChannelClosing: {
                initiator: 'Compact<u32>',
                sender: 'Compact<u32>',
                recipient: 'Compact<u32>',
            },
            RelayedFrom: {
                who: 'XcmV0MultiLocation',
                message: 'XcmV0Xcm'
            }
        }
    },
    /**
     * Lookup242: xcm::v0::order::Order<Call>
     **/
    XcmV0Order: {
        _enum: {
            Null: 'Null',
            DepositAsset: {
                assets: 'Vec<XcmV0MultiAsset>',
                dest: 'XcmV0MultiLocation',
            },
            DepositReserveAsset: {
                assets: 'Vec<XcmV0MultiAsset>',
                dest: 'XcmV0MultiLocation',
                effects: 'Vec<XcmV0Order>',
            },
            ExchangeAsset: {
                give: 'Vec<XcmV0MultiAsset>',
                receive: 'Vec<XcmV0MultiAsset>',
            },
            InitiateReserveWithdraw: {
                assets: 'Vec<XcmV0MultiAsset>',
                reserve: 'XcmV0MultiLocation',
                effects: 'Vec<XcmV0Order>',
            },
            InitiateTeleport: {
                assets: 'Vec<XcmV0MultiAsset>',
                dest: 'XcmV0MultiLocation',
                effects: 'Vec<XcmV0Order>',
            },
            QueryHolding: {
                queryId: 'Compact<u64>',
                dest: 'XcmV0MultiLocation',
                assets: 'Vec<XcmV0MultiAsset>',
            },
            BuyExecution: {
                fees: 'XcmV0MultiAsset',
                weight: 'u64',
                debt: 'u64',
                haltOnError: 'bool',
                xcm: 'Vec<XcmV0Xcm>'
            }
        }
    },
    /**
     * Lookup244: xcm::v0::Response
     **/
    XcmV0Response: {
        _enum: {
            Assets: 'Vec<XcmV0MultiAsset>'
        }
    },
    /**
     * Lookup245: xcm::v1::Xcm<Call>
     **/
    XcmV1Xcm: {
        _enum: {
            WithdrawAsset: {
                assets: 'XcmV1MultiassetMultiAssets',
                effects: 'Vec<XcmV1Order>',
            },
            ReserveAssetDeposited: {
                assets: 'XcmV1MultiassetMultiAssets',
                effects: 'Vec<XcmV1Order>',
            },
            ReceiveTeleportedAsset: {
                assets: 'XcmV1MultiassetMultiAssets',
                effects: 'Vec<XcmV1Order>',
            },
            QueryResponse: {
                queryId: 'Compact<u64>',
                response: 'XcmV1Response',
            },
            TransferAsset: {
                assets: 'XcmV1MultiassetMultiAssets',
                beneficiary: 'XcmV1MultiLocation',
            },
            TransferReserveAsset: {
                assets: 'XcmV1MultiassetMultiAssets',
                dest: 'XcmV1MultiLocation',
                effects: 'Vec<XcmV1Order>',
            },
            Transact: {
                originType: 'XcmV0OriginKind',
                requireWeightAtMost: 'u64',
                call: 'XcmDoubleEncoded',
            },
            HrmpNewChannelOpenRequest: {
                sender: 'Compact<u32>',
                maxMessageSize: 'Compact<u32>',
                maxCapacity: 'Compact<u32>',
            },
            HrmpChannelAccepted: {
                recipient: 'Compact<u32>',
            },
            HrmpChannelClosing: {
                initiator: 'Compact<u32>',
                sender: 'Compact<u32>',
                recipient: 'Compact<u32>',
            },
            RelayedFrom: {
                who: 'XcmV1MultilocationJunctions',
                message: 'XcmV1Xcm',
            },
            SubscribeVersion: {
                queryId: 'Compact<u64>',
                maxResponseWeight: 'Compact<u64>',
            },
            UnsubscribeVersion: 'Null'
        }
    },
    /**
     * Lookup247: xcm::v1::order::Order<Call>
     **/
    XcmV1Order: {
        _enum: {
            Noop: 'Null',
            DepositAsset: {
                assets: 'XcmV1MultiassetMultiAssetFilter',
                maxAssets: 'u32',
                beneficiary: 'XcmV1MultiLocation',
            },
            DepositReserveAsset: {
                assets: 'XcmV1MultiassetMultiAssetFilter',
                maxAssets: 'u32',
                dest: 'XcmV1MultiLocation',
                effects: 'Vec<XcmV1Order>',
            },
            ExchangeAsset: {
                give: 'XcmV1MultiassetMultiAssetFilter',
                receive: 'XcmV1MultiassetMultiAssets',
            },
            InitiateReserveWithdraw: {
                assets: 'XcmV1MultiassetMultiAssetFilter',
                reserve: 'XcmV1MultiLocation',
                effects: 'Vec<XcmV1Order>',
            },
            InitiateTeleport: {
                assets: 'XcmV1MultiassetMultiAssetFilter',
                dest: 'XcmV1MultiLocation',
                effects: 'Vec<XcmV1Order>',
            },
            QueryHolding: {
                queryId: 'Compact<u64>',
                dest: 'XcmV1MultiLocation',
                assets: 'XcmV1MultiassetMultiAssetFilter',
            },
            BuyExecution: {
                fees: 'XcmV1MultiAsset',
                weight: 'u64',
                debt: 'u64',
                haltOnError: 'bool',
                instructions: 'Vec<XcmV1Xcm>'
            }
        }
    },
    /**
     * Lookup249: xcm::v1::Response
     **/
    XcmV1Response: {
        _enum: {
            Assets: 'XcmV1MultiassetMultiAssets',
            Version: 'u32'
        }
    },
    /**
     * Lookup264: cumulus_pallet_dmp_queue::pallet::Call<T>
     **/
    CumulusPalletDmpQueueCall: {
        _enum: {
            service_overweight: {
                index: 'u64',
                weightLimit: 'u64'
            }
        }
    },
    /**
     * Lookup265: cumulus_pallet_xcmp_queue::pallet::Call<T>
     **/
    CumulusPalletXcmpQueueCall: {
        _enum: {
            service_overweight: {
                index: 'u64',
                weightLimit: 'u64',
            },
            suspend_xcm_execution: 'Null',
            resume_xcm_execution: 'Null',
            update_suspend_threshold: {
                _alias: {
                    new_: 'new',
                },
                new_: 'u32',
            },
            update_drop_threshold: {
                _alias: {
                    new_: 'new',
                },
                new_: 'u32',
            },
            update_resume_threshold: {
                _alias: {
                    new_: 'new',
                },
                new_: 'u32',
            },
            update_threshold_weight: {
                _alias: {
                    new_: 'new',
                },
                new_: 'u64',
            },
            update_weight_restrict_decay: {
                _alias: {
                    new_: 'new',
                },
                new_: 'u64',
            },
            update_xcmp_max_individual_weight: {
                _alias: {
                    new_: 'new',
                },
                new_: 'u64'
            }
        }
    },
    /**
     * Lookup266: eq_node_runtime::OriginCaller
     **/
    EqNodeRuntimeOriginCaller: {
        _enum: {
            system: 'FrameSupportDispatchRawOrigin',
            __Unused1: 'Null',
            Void: 'SpCoreVoid',
            __Unused3: 'Null',
            __Unused4: 'Null',
            __Unused5: 'Null',
            __Unused6: 'Null',
            __Unused7: 'Null',
            __Unused8: 'Null',
            __Unused9: 'Null',
            __Unused10: 'Null',
            __Unused11: 'Null',
            __Unused12: 'Null',
            __Unused13: 'Null',
            __Unused14: 'Null',
            __Unused15: 'Null',
            __Unused16: 'Null',
            __Unused17: 'Null',
            __Unused18: 'Null',
            __Unused19: 'Null',
            __Unused20: 'Null',
            __Unused21: 'Null',
            __Unused22: 'Null',
            __Unused23: 'Null',
            __Unused24: 'Null',
            __Unused25: 'Null',
            __Unused26: 'Null',
            __Unused27: 'Null',
            __Unused28: 'Null',
            __Unused29: 'Null',
            __Unused30: 'Null',
            __Unused31: 'Null',
            __Unused32: 'Null',
            __Unused33: 'Null',
            __Unused34: 'Null',
            PolkadotXcm: 'PalletXcmOrigin'
        }
    },
    /**
     * Lookup267: frame_support::dispatch::RawOrigin<sp_core::crypto::AccountId32>
     **/
    FrameSupportDispatchRawOrigin: {
        _enum: {
            Root: 'Null',
            Signed: 'AccountId32',
            None: 'Null'
        }
    },
    /**
     * Lookup268: pallet_xcm::pallet::Origin
     **/
    PalletXcmOrigin: {
        _enum: {
            Xcm: 'XcmV1MultiLocation',
            Response: 'XcmV1MultiLocation'
        }
    },
    /**
     * Lookup269: sp_core::Void
     **/
    SpCoreVoid: 'Null',
    /**
     * Lookup270: pallet_utility::pallet::Error<T>
     **/
    PalletUtilityError: {
        _enum: ['TooManyCalls']
    },
    /**
     * Lookup272: eq_session_manager::pallet::Error<T>
     **/
    EqSessionManagerError: {
        _enum: ['AlreadyAdded', 'AlreadyRemoved', 'NotRegistered']
    },
    /**
     * Lookup274: pallet_authorship::UncleEntryItem<BlockNumber, primitive_types::H256, sp_core::crypto::AccountId32>
     **/
    PalletAuthorshipUncleEntryItem: {
        _enum: {
            InclusionHeight: 'u32',
            Uncle: '(H256,Option<AccountId32>)'
        }
    },
    /**
     * Lookup275: pallet_authorship::pallet::Error<T>
     **/
    PalletAuthorshipError: {
        _enum: ['InvalidUncleParent', 'UnclesAlreadySet', 'TooManyUncles', 'GenesisUncle', 'TooHighUncle', 'UncleAlreadyIncluded', 'OldUncle']
    },
    /**
     * Lookup280: sp_core::crypto::KeyTypeId
     **/
    SpCoreCryptoKeyTypeId: '[u8;4]',
    /**
     * Lookup281: pallet_session::pallet::Error<T>
     **/
    PalletSessionError: {
        _enum: ['InvalidProof', 'NoAssociatedValidatorId', 'DuplicatedKey', 'NoKeys', 'NoAccount']
    },
    /**
     * Lookup284: eq_primitives::asset::AssetData<eq_primitives::asset::Asset>
     **/
    EqPrimitivesAssetAssetData: {
        id: 'u64',
        lot: 'u128',
        priceStep: 'u128',
        makerFee: 'u128',
        takerFee: 'u128',
        assetXcmData: 'Option<EqPrimitivesAssetAssetXcmData>',
        debtWeight: 'u128',
        buyoutPriority: 'u64',
        assetType: 'EqPrimitivesAssetAssetType',
        isDexEnabled: 'bool',
        collateralEnabled: 'bool'
    },
    /**
     * Lookup285: eq_assets::pallet::Error<T>
     **/
    EqAssetsError: {
        _enum: ['AssetAlreadyExists', 'AssetNotExists', 'DebtWeightNegative', 'DebtWeightMoreThanOne', 'AssetNameWrongLength', 'AssetNameWrongSymbols', 'CollateralMustBeDisabledWithoutPrices']
    },
    /**
     * Lookup286: frame_support::PalletId
     **/
    FrameSupportPalletId: '[u8;8]',
    /**
     * Lookup287: eq_distribution::pallet::Error<T, I>
     **/
    EqDistributionError: {
        _enum: ['ExistingVestingSchedule', 'AmountLow']
    },
    /**
     * Lookup289: eq_treasury::pallet::Error<T>
     **/
    EqTreasuryError: {
        _enum: ['NothingToSell', 'BuyEqTokensRestricted', 'NoPrice', 'BadPrice', 'InsufficientTreasuryBalance', 'InsufficientAccountBalance', 'Overflow']
    },
    /**
     * Lookup291: eq_primitives::signed_balance::SignedBalance<Balance>
     **/
    EqPrimitivesSignedBalance: {
        _enum: {
            Positive: 'u128',
            Negative: 'u128'
        }
    },
    /**
     * Lookup292: eq_balances::pallet::Error<T>
     **/
    EqBalancesError: {
        _enum: ['Overflow', 'DeadAccount', 'NotAllowedToChangeBalance', 'TransfersAreDisabled', 'MethodNotAllowed', 'NotAllowedToDeleteAccount', 'NotEnoughToBuyoutEq', 'NotEnoughToKeepAlive', 'ExchangeSameAsset', 'TransferToSubaccount', 'XcmNotEnoughToPayFee', 'XcmSend', 'XcmDisabled', 'XcmInvalidDestination', 'XcmUnknownAsset']
    },
    /**
     * Lookup294: pallet_transaction_payment::Releases
     **/
    PalletTransactionPaymentReleases: {
        _enum: ['V1Ancient', 'V2']
    },
    /**
     * Lookup296: frame_support::weights::WeightToFeeCoefficient<Balance>
     **/
    FrameSupportWeightsWeightToFeeCoefficient: {
        coeffInteger: 'u128',
        coeffFrac: 'Perbill',
        negative: 'bool',
        degree: 'u8'
    },
    /**
     * Lookup297: pallet_sudo::pallet::Error<T>
     **/
    PalletSudoError: {
        _enum: ['RequireSudo']
    },
    /**
     * Lookup298: eq_whitelists::pallet::Error<T>
     **/
    EqWhitelistsError: {
        _enum: ['AlreadyAdded', 'AlreadyRemoved']
    },
    /**
     * Lookup300: eq_rate::pallet::Error<T>
     **/
    EqRateError: {
        _enum: ['InvalidOffset', 'AutoReinitIsDisabled', 'MethodNotAllowed', 'NoPrices', 'NoFinancial', 'ExternalError', 'MathError', 'ValueError', 'ValidationError']
    },
    /**
     * Lookup304: eq_vesting::pallet::Error<T, I>
     **/
    EqVestingError: {
        _enum: ['NotVesting', 'ExistingVestingSchedule', 'AmountLow', 'TransfersAreDisabled', 'MethodNotAllowed']
    },
    /**
     * Lookup306: eq_claim::pallet::Error<T>
     **/
    EqClaimError: {
        _enum: ['InvalidEthereumSignature', 'SignerHasNoClaim', 'SenderHasNoClaim', 'PotUnderflow', 'InvalidStatement', 'VestedBalanceExists', 'Overflow', 'MethodNotAllowed', 'InvalidReceiver']
    },
    /**
     * Lookup308: eq_primitives::UserGroup
     **/
    EqPrimitivesUserGroup: {
        _enum: ['Unknown', 'Balances', 'Bailsmen', 'Borrowers', 'Lenders']
    },
    /**
     * Lookup310: eq_primitives::TotalAggregates<Balance>
     **/
    EqPrimitivesTotalAggregates: {
        collateral: 'u128',
        debt: 'u128'
    },
    /**
     * Lookup312: eq_subaccounts::pallet::Error<T>
     **/
    EqSubaccountsError: {
        _enum: ['AlreadyHasSubaccount', 'NoSubaccountOfThisType', 'AccountInWhiteList', 'TransfersAreDisabled', 'Debt', 'EntropyError']
    },
    /**
     * Lookup313: financial_pallet::PriceUpdate<substrate_fixed::FixedI128<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UTerm, typenum::bit::B1>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>>>
     **/
    FinancialPalletPriceUpdate: {
        periodStart: 'FinancialPalletDuration',
        time: 'FinancialPalletDuration',
        price: 'SubstrateFixedFixedI128'
    },
    /**
     * Lookup314: financial_pallet::PriceLog<substrate_fixed::FixedI128<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UTerm, typenum::bit::B1>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>>>
     **/
    FinancialPalletPriceLog: {
        latestTimestamp: 'FinancialPalletDuration',
        prices: 'FinancialPrimitivesCapVec'
    },
    /**
     * Lookup315: financial_primitives::capvec::CapVec<substrate_fixed::FixedI128<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UTerm, typenum::bit::B1>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>>>
     **/
    FinancialPrimitivesCapVec: {
        headIndex: 'u32',
        lenCap: 'u32',
        items: 'Vec<SubstrateFixedFixedI128>'
    },
    /**
     * Lookup316: financial_pallet::PortfolioMetrics<substrate_fixed::FixedI128<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UInt<typenum::uint::UTerm, typenum::bit::B1>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>, typenum::bit::B0>>>
     **/
    FinancialPalletPortfolioMetrics: {
        periodStart: 'FinancialPalletDuration',
        periodEnd: 'FinancialPalletDuration',
        zScore: 'u32',
        volatility: 'SubstrateFixedFixedI128',
        valueAtRisk: 'SubstrateFixedFixedI128'
    },
    /**
     * Lookup317: financial_pallet::Error<T>
     **/
    FinancialPalletError: {
        _enum: ['PeriodIsInThePast', 'Overflow', 'DivisionByZero', 'NotEnoughPoints', 'NotImplemented', 'InvalidStorage', 'InvalidPeriodStart', 'Transcendental', 'InvalidArgument', 'InvalidConstant', 'MethodNotAllowed']
    },
    /**
     * Lookup320: chainbridge::ProposalVotes<sp_core::crypto::AccountId32, BlockNumber>
     **/
    ChainbridgeProposalVotes: {
        votesFor: 'Vec<AccountId32>',
        votesAgainst: 'Vec<AccountId32>',
        status: 'ChainbridgeProposalStatus',
        expiry: 'u32'
    },
    /**
     * Lookup321: chainbridge::ProposalStatus
     **/
    ChainbridgeProposalStatus: {
        _enum: ['Initiated', 'Approved', 'Rejected']
    },
    /**
     * Lookup322: chainbridge::pallet::Error<T>
     **/
    ChainbridgeError: {
        _enum: ['ThresholdNotSet', 'InvalidChainId', 'InvalidThreshold', 'InvalidFee', 'InvalidProposalLifetime', 'ChainNotWhitelisted', 'ChainAlreadyWhitelisted', 'ResourceDoesNotExist', 'RelayerAlreadyExists', 'RelayerInvalid', 'MustBeRelayer', 'RelayerAlreadyVoted', 'ProposalAlreadyExists', 'ProposalDoesNotExist', 'ProposalNotComplete', 'ProposalAlreadyComplete', 'ProposalExpired', 'AllowabilityEqual', 'DisabledChain']
    },
    /**
     * Lookup324: eq_bridge::pallet::Error<T>
     **/
    EqBridgeError: {
        _enum: ['InvalidTransfer', 'InvalidResourceId', 'InvalidAssetType', 'DisabledChain', 'ChainNotWhitelisted', 'TransferAmountLowerMinimum', 'InvalidAccount']
    },
    /**
     * Lookup325: eq_multisig_sudo::pallet::Multisig<sp_core::crypto::AccountId32>
     **/
    EqMultisigSudoMultisig: {
        call: 'Bytes',
        proposer: 'AccountId32',
        approvals: 'Vec<AccountId32>',
        cancels: 'Vec<AccountId32>'
    },
    /**
     * Lookup326: eq_multisig_sudo::pallet::Error<T>
     **/
    EqMultisigSudoError: {
        _enum: ['AlreadyInKeyList', 'NotInKeyList', 'InvalidThresholdValue', 'FewSignatories', 'ProposalNotFound', 'NotProposalOwner', 'AlreadyApproved', 'AlreadyCancelled']
    },
    /**
     * Lookup327: eq_lockdrop::pallet::Error<T>
     **/
    EqLockdropError: {
        _enum: ['OutOfLockPeriod', 'LockPeriodNotOver', 'LockStartNotEmpty', 'MultipleTransferWithVesting', 'LockAmountLow']
    },
    /**
     * Lookup329: pallet_multisig::Multisig<BlockNumber, Balance, sp_core::crypto::AccountId32>
     **/
    PalletMultisigMultisig: {
        when: 'PalletMultisigTimepoint',
        deposit: 'u128',
        depositor: 'AccountId32',
        approvals: 'Vec<AccountId32>'
    },
    /**
     * Lookup331: pallet_multisig::pallet::Error<T>
     **/
    PalletMultisigError: {
        _enum: ['MinimumThreshold', 'AlreadyApproved', 'NoApprovalsNeeded', 'TooFewSignatories', 'TooManySignatories', 'SignatoriesOutOfOrder', 'SenderInSignatories', 'NotFound', 'NotOwner', 'NoTimepoint', 'WrongTimepoint', 'UnexpectedTimepoint', 'MaxWeightTooLow', 'AlreadyStored']
    },
    /**
     * Lookup334: pallet_proxy::ProxyDefinition<sp_core::crypto::AccountId32, eq_primitives::proxy::ProxyType, BlockNumber>
     **/
    PalletProxyProxyDefinition: {
        delegate: 'AccountId32',
        proxyType: 'EqPrimitivesProxyProxyType',
        delay: 'u32'
    },
    /**
     * Lookup338: pallet_proxy::Announcement<sp_core::crypto::AccountId32, primitive_types::H256, BlockNumber>
     **/
    PalletProxyAnnouncement: {
        real: 'AccountId32',
        callHash: 'H256',
        height: 'u32'
    },
    /**
     * Lookup340: pallet_proxy::pallet::Error<T>
     **/
    PalletProxyError: {
        _enum: ['TooMany', 'NotFound', 'NotProxy', 'Unproxyable', 'Duplicate', 'NoPermission', 'Unannounced', 'NoSelfProxy']
    },
    /**
     * Lookup341: eq_migration::pallet::Error<T>
     **/
    EqMigrationError: {
        _enum: ['MigrationIsInProgress', 'MathOverflow']
    },
    /**
     * Lookup342: pallet_xcm::pallet::QueryStatus<BlockNumber>
     **/
    PalletXcmQueryStatus: {
        _enum: {
            Pending: {
                responder: 'XcmVersionedMultiLocation',
                maybeNotify: 'Option<(u8,u8)>',
                timeout: 'u32',
            },
            VersionNotifier: {
                origin: 'XcmVersionedMultiLocation',
                isActive: 'bool',
            },
            Ready: {
                response: 'XcmVersionedResponse',
                at: 'u32'
            }
        }
    },
    /**
     * Lookup345: xcm::VersionedResponse
     **/
    XcmVersionedResponse: {
        _enum: {
            V0: 'XcmV0Response',
            V1: 'XcmV1Response',
            V2: 'XcmV2Response'
        }
    },
    /**
     * Lookup351: pallet_xcm::pallet::VersionMigrationStage
     **/
    PalletXcmVersionMigrationStage: {
        _enum: {
            MigrateSupportedVersion: 'Null',
            MigrateVersionNotifiers: 'Null',
            NotifyCurrentTargets: 'Option<Bytes>',
            MigrateAndNotifyOldTargets: 'Null'
        }
    },
    /**
     * Lookup353: pallet_xcm::pallet::Error<T>
     **/
    PalletXcmError: {
        _enum: ['Unreachable', 'SendFailure', 'Filtered', 'UnweighableMessage', 'DestinationNotInvertible', 'Empty', 'CannotReanchor', 'TooManyAssets', 'InvalidOrigin', 'BadVersion', 'BadLocation', 'NoSubscription', 'AlreadySubscribed']
    },
    /**
     * Lookup354: cumulus_pallet_dmp_queue::ConfigData
     **/
    CumulusPalletDmpQueueConfigData: {
        maxIndividual: 'u64'
    },
    /**
     * Lookup355: cumulus_pallet_dmp_queue::PageIndexData
     **/
    CumulusPalletDmpQueuePageIndexData: {
        beginUsed: 'u32',
        endUsed: 'u32',
        overweightCount: 'u64'
    },
    /**
     * Lookup358: cumulus_pallet_dmp_queue::pallet::Error<T>
     **/
    CumulusPalletDmpQueueError: {
        _enum: ['Unknown', 'OverLimit']
    },
    /**
     * Lookup360: cumulus_pallet_xcmp_queue::InboundChannelDetails
     **/
    CumulusPalletXcmpQueueInboundChannelDetails: {
        sender: 'u32',
        state: 'CumulusPalletXcmpQueueInboundState',
        messageMetadata: 'Vec<(u32,PolkadotParachainPrimitivesXcmpMessageFormat)>'
    },
    /**
     * Lookup361: cumulus_pallet_xcmp_queue::InboundState
     **/
    CumulusPalletXcmpQueueInboundState: {
        _enum: ['Ok', 'Suspended']
    },
    /**
     * Lookup364: polkadot_parachain::primitives::XcmpMessageFormat
     **/
    PolkadotParachainPrimitivesXcmpMessageFormat: {
        _enum: ['ConcatenatedVersionedXcm', 'ConcatenatedEncodedBlob', 'Signals']
    },
    /**
     * Lookup367: cumulus_pallet_xcmp_queue::OutboundChannelDetails
     **/
    CumulusPalletXcmpQueueOutboundChannelDetails: {
        recipient: 'u32',
        state: 'CumulusPalletXcmpQueueOutboundState',
        signalsExist: 'bool',
        firstIndex: 'u16',
        lastIndex: 'u16'
    },
    /**
     * Lookup368: cumulus_pallet_xcmp_queue::OutboundState
     **/
    CumulusPalletXcmpQueueOutboundState: {
        _enum: ['Ok', 'Suspended']
    },
    /**
     * Lookup370: cumulus_pallet_xcmp_queue::QueueConfigData
     **/
    CumulusPalletXcmpQueueQueueConfigData: {
        suspendThreshold: 'u32',
        dropThreshold: 'u32',
        resumeThreshold: 'u32',
        thresholdWeight: 'u64',
        weightRestrictDecay: 'u64',
        xcmpMaxIndividualWeight: 'u64'
    },
    /**
     * Lookup372: cumulus_pallet_xcmp_queue::pallet::Error<T>
     **/
    CumulusPalletXcmpQueueError: {
        _enum: ['FailedToSend', 'BadXcmOrigin', 'BadXcm', 'BadOverweightIndex', 'WeightOverLimit']
    },
    /**
     * Lookup374: sp_runtime::MultiSignature
     **/
    SpRuntimeMultiSignature: {
        _enum: {
            Ed25519: 'SpCoreEd25519Signature',
            Sr25519: 'SpCoreSr25519Signature',
            Ecdsa: 'SpCoreEcdsaSignature'
        }
    },
    /**
     * Lookup375: sp_core::sr25519::Signature
     **/
    SpCoreSr25519Signature: '[u8;64]',
    /**
     * Lookup376: sp_core::ecdsa::Signature
     **/
    SpCoreEcdsaSignature: '[u8;65]',
    /**
     * Lookup378: frame_system::extensions::check_spec_version::CheckSpecVersion<T>
     **/
    FrameSystemExtensionsCheckSpecVersion: 'Null',
    /**
     * Lookup379: frame_system::extensions::check_tx_version::CheckTxVersion<T>
     **/
    FrameSystemExtensionsCheckTxVersion: 'Null',
    /**
     * Lookup380: frame_system::extensions::check_genesis::CheckGenesis<T>
     **/
    FrameSystemExtensionsCheckGenesis: 'Null',
    /**
     * Lookup383: frame_system::extensions::check_nonce::CheckNonce<T>
     **/
    FrameSystemExtensionsCheckNonce: 'Compact<u32>',
    /**
     * Lookup384: frame_system::extensions::check_weight::CheckWeight<T>
     **/
    FrameSystemExtensionsCheckWeight: 'Null',
    /**
     * Lookup385: pallet_transaction_payment::ChargeTransactionPayment<T>
     **/
    PalletTransactionPaymentChargeTransactionPayment: 'Compact<u128>',
    /**
     * Lookup386: eq_rate::reinit_extension::ReinitAccount<eq_node_runtime::Runtime, eq_node_runtime::CallsWithReinit>
     **/
    EqRateReinitExtensionReinitAccount: 'Null',
    /**
     * Lookup387: eq_node_runtime::Runtime
     **/
    EqNodeRuntimeRuntime: 'Null',
    /**
     * Lookup388: eq_node_runtime::CallsWithReinit
     **/
    EqNodeRuntimeCallsWithReinit: 'Null',
    /**
     * Lookup389: eq_claim::PrevalidateAttests<eq_node_runtime::Runtime>
     **/
    EqClaimPrevalidateAttests: 'Null'
};
