{

"types": {
  "Balance": "u128",
  "BalanceOf": "Balance",
  "Block": "GenericBlock",
  "Call": "GenericCall",
  "H160": "H160",
  "H256": "H256",
  "H512": "H512",
  "Hash": "H256",
  "CallHash": "Hash",
  "CallHashOf": "CallHash",
  "Fixed64": "u64",
  "Fixed128": "u128",
  "AccountIdOf": "AccountId",
  "MultiAddress": "GenericMultiAddress",
  "AccountVoteSplit": {
    "type": "struct",
    "type_mapping": [
      [
        "aye",
        "Balance"
      ],
      [
        "nay",
        "Balance"
      ]
    ]
  },
  "AccountVoteStandard": {
    "type": "struct",
    "type_mapping": [
      [
        "vote",
        "Vote"
      ],
      [
        "balance",
        "Balance"
      ]
    ]
  },
  "AccountVote": {
    "type": "enum",
    "type_mapping": [
      [
        "Standard",
        "AccountVoteStandard"
      ],
      [
        "Split",
        "AccountVoteSplit"
      ]
    ]
  },
  "Delegations": {
    "type": "struct",
    "type_mapping": [
      [
        "votes",
        "Balance"
      ],
      [
        "capital",
        "Balance"
      ]
    ]
  },
  "PriorLock": {
    "type": "struct",
    "type_mapping": [
       ["blockNumber", "BlockNumber"],
       ["balance", "Balance"]
    ]
  },
  "ReferendumInfoFinished": {
    "type": "struct",
    "type_mapping": [
      [
        "approved",
        "bool"
      ],
      [
        "end",
        "BlockNumber"
      ]
    ]
  },
  "Tally": {
    "type": "struct",
    "type_mapping": [
      [
        "ayes",
        "Balance"
      ],
      [
        "nays",
        "Balance"
      ],
      [
        "turnout",
        "Balance"
      ]
    ]
  },
  "ReferendumStatus": {
    "type": "struct",
    "type_mapping": [
      [
        "end",
        "BlockNumber"
      ],
      [
        "proposalHash",
        "Hash"
      ],
      [
        "threshold",
        "VoteThreshold"
      ],
      [
        "delay",
        "BlockNumber"
      ],
      [
        "tally",
        "Tally"
      ]
    ]
  },
  "ReferendumInfo": {
    "type": "enum",
    "type_mapping": [
      [
        "Ongoing",
        "ReferendumStatus"
      ],
      [
        "Finished",
        "ReferendumInfoFinished"
      ]
    ]
  },
  "VotingDirectVote": {
    "type": "struct",
    "type_mapping": [
       ["referendumIndex", "ReferendumIndex"],
       ["accountVote", "AccountVote"]
    ]
  },
  "VotingDirect": {
    "type": "struct",
    "type_mapping": [
      [
        "votes",
        "Vec<VotingDirectVote>"
      ],
      [
        "delegations",
        "Delegations"
      ],
      [
        "prior",
        "PriorLock"
      ]
    ]
  },
  "VotingDelegating": {
    "type": "struct",
    "type_mapping": [
      [
        "balance",
        "Balance"
      ],
      [
        "target",
        "AccountId"
      ],
      [
        "conviction",
        "Conviction"
      ],
      [
        "delegations",
        "Delegations"
      ],
      [
        "prior",
        "PriorLock"
      ]
    ]
  },
  "Voting": {
    "type": "enum",
    "type_mapping": [
      [
        "Direct",
        "VotingDirect"
      ],
      [
        "Delegating",
        "VotingDelegating"
      ]
    ]
  },
  "(AccountId, Balance)": {
    "type": "struct",
    "type_mapping": [
      [
        "account",
        "AccountId"
      ],
      [
        "balance",
        "Balance"
      ]
    ]
  },
  "(BalanceOf<T, I>, BidKind<AccountId, BalanceOf<T, I>>)": {
    "type": "struct",
    "type_mapping": [
      [
        "balance",
        "Balance"
      ],
      [
        "bidkind",
        "BidKind"
      ]
    ]
  },
  "RefCount": "u32",
  "Moment": "u64",
  "AccountData": {
    "type": "struct",
    "type_mapping": [
      [
        "free",
        "Balance"
      ],
      [
        "reserved",
        "Balance"
      ],
      [
        "miscFrozen",
        "Balance"
      ],
      [
        "feeFrozen",
        "Balance"
      ]
    ]
  },
  "AccountInfo<Index, AccountData>": {
    "type": "struct",
    "type_mapping": [
      [
        "nonce",
        "Index"
      ],
      [
        "c",
        "RefCount"
      ],
      [
        "data",
        "AccountData"
      ]
    ]
  },
  "ActiveEraInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "index",
        "EraIndex"
      ],
      [
        "start",
        "Option<Moment>"
      ]
    ]
  },
  "BlockNumber": "u32",
  "CandidateReceipt": {
    "type": "struct",
    "type_mapping": [
      [
        "parachainIndex",
        "ParaId"
      ],
      [
        "relayParent",
        "Hash"
      ],
      [
        "head_data",
        "HeadData"
      ],
      [
        "collator",
        "CollatorId"
      ],
      [
        "signature",
        "CollatorSignature"
      ],
      [
        "povBlockHash",
        "Hash"
      ],
      [
        "globalValidation",
        "GlobalValidationSchedule"
      ],
      [
        "localValidation",
        "LocalValidationData"
      ],
      [
        "commitments",
        "CandidateCommitments"
      ]
    ]
  },
  "ValidityVote": {
    "type": "struct",
    "type_mapping": [
      [
        "accountId",
        "AccountId"
      ],
      [
        "validityAttestation",
        "ValidityAttestation"
      ]
    ]
  },
  "AttestedCandidate": {
    "type": "struct",
    "type_mapping": [
      [
        "candidate",
        "AbridgedCandidateReceipt"
      ],
      [
        "validityVotes",
        "Vec<ValidityAttestation>"
      ],
      [
        "validatorIndices",
        "BitVec"
      ]
    ]
  },
  "LockIdentifier": "[u8; 8]",
  "TransactionPriority": "u64",
  "BalanceLock": {
    "type": "struct",
    "type_mapping": [
      [
        "id",
        "LockIdentifier"
      ],
      [
        "amount",
        "Balance"
      ],
      [
        "reasons",
        "Reasons"
      ]
    ]
  },
  "FullIdentification": {
    "type": "struct",
    "type_mapping": [
       ["total", "Compact<Balance>"],
       ["own", "Compact<Balance>"],
       ["others", "Vec<IndividualExposure>"]
    ]
  },
  "IdentificationTuple": {
    "type": "struct",
    "type_mapping": [
       ["validatorId", "ValidatorId"],
       ["exposure", "FullIdentification"]
    ]
  },
  "SetId": "u64",
  "Reasons": {
    "type": "enum",
    "value_list": [
      "Fee",
      "Misc",
      "All"
    ]
  },
  "RoundNumber": "U64",
  "SessionIndex": "u32",
  "AuctionIndex": "u32",
  "AuthIndex": "u32",
  "AuthorityIndex": "u64",
  "Signature": "H512",
  "CollatorSignature": "Signature",
  "AuthorityWeight": "u64",
  "NextAuthority": {
    "type": "struct",
    "type_mapping": [
       ["AuthorityId", "AuthorityId"],
       ["weight", "AuthorityWeight"]
    ]
  },
  "AuthorityList": "Vec<NextAuthority>",
  "BalanceUpload": {
    "type": "struct",
    "type_mapping": [
      [
        "accountId",
        "AccountId"
      ],
      [
        "balance",
        "u64"
      ]
    ]
  },
  "CollatorId": "[u8; 32]",
  "ContractInfo": {
    "type": "enum",
    "type_mapping": [
      [
        "Alive",
        "AliveContractInfo"
      ],
      [
        "Tombstone",
        "TombstoneContractInfo"
      ]
    ]
  },
  "TrieId": "Bytes",
  "RawAliveContractInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "trie_id",
        "TrieId"
      ],
      [
        "storage_size",
        "u32"
      ],
      [
        "code_hash",
        "CodeHash"
      ],
      [
        "rent_allowance",
        "Balance"
      ],
      [
        "deduct_block",
        "BlockNumber"
      ],
      [
        "last_write",
        "Option<BlockNumber>"
      ]
    ]
  },
  "Pays": {
    "type": "enum",
    "value_list": [
      "Yes",
      "No"
    ]
  },
  "DispatchClass": {
    "type": "enum",
    "value_list": [
      "Normal",
      "Operational",
      "Mandatory"
    ]
  },
  "DispatchInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "weight",
        "Weight"
      ],
      [
        "class",
        "DispatchClass"
      ],
      [
        "paysFee",
        "Pays"
      ]
    ]
  },
  "EgressQueueRoot": {
    "type": "struct",
    "type_mapping": [
      [
        "paraId",
        "ParaId"
      ],
      [
        "hash",
        "Hash"
      ]
    ]
  },
  "EventIndex": "u32",
  "Extrinsic": "ExtrinsicsDecoder",
  "ExtrinsicPayloadValue": {
    "type": "struct",
    "type_mapping": [
      [
        "call",
        "CallBytes"
      ],
      [
        "era",
        "Era"
      ],
      [
        "nonce",
        "Compact<Index>"
      ],
      [
        "tip",
        "Compact<Balance>"
      ],
      [
        "specVersion",
        "u32"
      ],
      [
        "transactionVersion",
        "u32"
      ],
      [
        "genesisHash",
        "Hash"
      ],
      [
        "blockHash",
        "Hash"
      ]
    ]
  },
  "Gas": "u64",
  "IdentityFields": {
    "type": "set",
    "value_type": "u64",
    "value_list": {
      "Display": 1,
      "Legal": 2,
      "Web": 4,
      "Riot": 8,
      "Email": 16,
      "PgpFingerprint": 32,
      "Image": 64,
      "Twitter": 128
    }
  },
  "IdentityInfoAdditional": {
    "type": "struct",
    "type_mapping": [
       ["field", "Data"],
       ["value", "Data"]
    ]
  },
  "IdentityInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "additional",
        "Vec<IdentityInfoAdditional>"
      ],
      [
        "display",
        "Data"
      ],
      [
        "legal",
        "Data"
      ],
      [
        "web",
        "Data"
      ],
      [
        "riot",
        "Data"
      ],
      [
        "email",
        "Data"
      ],
      [
        "pgpFingerprint",
        "Option<H160>"
      ],
      [
        "image",
        "Data"
      ],
      [
        "twitter",
        "Data"
      ]
    ]
  },
  "IdentityJudgement": {
    "type": "enum",
    "type_mapping": [
      [
        "Unknown",
        "Null"
      ],
      [
        "FeePaid",
        "Balance"
      ],
      [
        "Reasonable",
        "Null"
      ],
      [
        "KnownGood",
        "Null"
      ],
      [
        "OutOfDate",
        "Null"
      ],
      [
        "LowQuality",
        "Null"
      ],
      [
        "Erroneous",
        "Null"
      ]
    ]
  },
  "Judgement": "IdentityJudgement",
  "Judgement<BalanceOf>": "IdentityJudgement",
  "LeasePeriod": "BlockNumber",
  "LeasePeriodOf": "LeasePeriod",
  "(LeasePeriodOf, IncomingParachain<AccountId, Hash>)": {
    "type": "struct",
    "type_mapping": [
      [
        "leasePeriod",
        "LeasePeriodOf"
      ],
      [
        "incomingParachain",
        "IncomingParachain"
      ]
    ]
  },
  "(ParaId, Option<(CollatorId, Retriable)>)": {
    "type": "struct",
    "type_mapping": [
      [
        "ParaId",
        "ParaId"
      ],
      [
        "CollatorId-Retriable",
        "Option<(CollatorId, Retriable)>"
      ]
    ]
  },
  "MaybeVrf": "Option<VrfData>",
  "MemberCount": "u32",
  "MomentOf": "Moment",
  "MoreAttestations": {
    "type": "struct",
    "type_mapping": []
  },
  "Multiplier": "Fixed128",
  "Timepoint": {
    "type": "struct",
    "type_mapping": [
      [
        "height",
        "BlockNumber"
      ],
      [
        "index",
        "u32"
      ]
    ]
  },
  "Multisig": {
    "type": "struct",
    "type_mapping": [
      [
        "when",
        "Timepoint"
      ],
      [
        "deposit",
        "Balance"
      ],
      [
        "depositor",
        "AccountId"
      ],
      [
        "approvals",
        "Vec<AccountId>"
      ]
    ]
  },
  "Offender": "IdentificationTuple",
  "PhantomData": "Null",
  "sp_std::marker::PhantomData<(AccountId, Event)>": "PhantomData",
  "Reporter": "AccountId",
  "OffenceDetails": {
    "type": "struct",
    "type_mapping": [
      [
        "offender",
        "Offender"
      ],
      [
        "reporters",
        "Vec<Reporter>"
      ]
    ]
  },
  "OpenTipFinder": "(AccountId, Balance)",
  "OpenTipTip": "(AccountId, Balance)",
  "OpenTip": {
    "type": "struct",
    "type_mapping": [
      [
        "reason",
        "Hash"
      ],
      [
        "who",
        "AccountId"
      ],
      [
        "finder",
        "AccountId"
      ],
      [
        "deposit",
        "Balance"
      ],
      [
        "closes",
        "Option<BlockNumber>"
      ],
      [
        "tips",
        "Vec<OpenTipTip>"
      ],
      [
        "findersFee",
        "bool"
      ]
    ]
  },
  "ParaId": "u32",
  "ParaIdOf": "ParaId",
  "ParaScheduling": {
    "type": "enum",
    "value_list": [
      "Always",
      "Dynamic"
    ]
  },
  "ParaInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "scheduling",
        "Scheduling"
      ]
    ]
  },
  "Percent": "u8",
  "SlotNumber": "u64",
  "VrfData": "[u8; 32]",
  "VrfProof": "[u8; 64]",
  "RawAuraPreDigest": {
    "type": "struct",
    "type_mapping": [
      [
        "slotNumber",
        "u64"
      ]
    ]
  },
  "RawBabePreDigest": {
    "type": "enum",
    "type_mapping": [
      [
        "Phantom",
        "Null"
      ],
      [
        "Primary",
        "RawBabePreDigestPrimary"
      ],
      [
        "SecondaryPlain",
        "RawBabePreDigestSecondaryPlain"
      ],
      [
        "SecondaryVRF",
        "RawBabePreDigestSecondaryVRF"
      ]
    ]
  },
  "RawBabePreDigestPrimary": {
    "type": "struct",
    "type_mapping": [
      [
        "authorityIndex",
        "u32"
      ],
      [
        "slotNumber",
        "SlotNumber"
      ],
      [
        "vrfOutput",
        "VrfOutput"
      ],
      [
        "vrfProof",
        "VrfProof"
      ]
    ]
  },
  "RawBabePreDigestSecondaryPlain": {
    "type": "struct",
    "type_mapping": [
      [
        "authorityIndex",
        "u32"
      ],
      [
        "slotNumber",
        "SlotNumber"
      ]
    ]
  },
  "RawBabePreDigestSecondaryVRF": {
    "type": "struct",
    "type_mapping": [
      [
        "authorityIndex",
        "u32"
      ],
      [
        "slotNumber",
        "SlotNumber"
      ],
      [
        "vrfOutput",
        "VrfOutput"
      ],
      [
        "vrfProof",
        "VrfProof"
      ]
    ]
  },
  "ReferendumInfo<BlockNumber, Proposal>": {
    "type": "struct",
    "type_mapping": [
      [
        "end",
        "BlockNumber"
      ],
      [
        "proposal",
        "Proposal"
      ],
      [
        "threshold",
        "VoteThreshold"
      ],
      [
        "delay",
        "BlockNumber"
      ]
    ]
  },
  "(ReferendumInfo<BlockNumber, Proposal>)": "ReferendumInfo<BlockNumber, Proposal>",
  "ReferendumInfo<BlockNumber, Hash>": {
    "type": "struct",
    "type_mapping": [
      [
        "end",
        "BlockNumber"
      ],
      [
        "proposalHash",
        "Hash"
      ],
      [
        "threshold",
        "VoteThreshold"
      ],
      [
        "delay",
        "BlockNumber"
      ]
    ]
  },
  "(ReferendumInfo<BlockNumber, Hash>)": "ReferendumInfo<BlockNumber, Hash>",
  "RegistrarIndex": "u32",
  "RegistrarInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "account",
        "AccountId"
      ],
      [
        "fee",
        "Balance"
      ],
      [
        "fields",
        "IdentityFields"
      ]
    ]
  },
  "RegistrationJudgement": {
    "type": "struct",
    "type_mapping": [
       ["registrarIndex", "RegistrarIndex"],
       ["judgement", "Judgement"]
    ]
  },
  "Registration": {
    "type": "struct",
    "type_mapping": [
      [
        "judgements",
        "Vec<RegistrationJudgement>"
      ],
      [
        "deposit",
        "Balance"
      ],
      [
        "info",
        "IdentityInfo"
      ]
    ]
  },
  "ReportIdOf": "Hash",
  "Schedule": {
    "type": "struct",
    "type_mapping": [
      [
        "version",
        "u32"
      ],
      [
        "putCodePerByteCost",
        "Gas"
      ],
      [
        "growMemCost",
        "Gas"
      ],
      [
        "regularOpCost",
        "Gas"
      ],
      [
        "returnDataPerByteCost",
        "Gas"
      ],
      [
        "eventDataPerByteCost",
        "Gas"
      ],
      [
        "eventPerTopicCost",
        "Gas"
      ],
      [
        "eventBaseCost",
        "Gas"
      ],
      [
        "sandboxDataReadCost",
        "Gas"
      ],
      [
        "sandboxDataWriteCost",
        "Gas"
      ],
      [
        "transferCost",
        "Gas"
      ],
      [
        "maxEventTopics",
        "u32"
      ],
      [
        "maxStackHeight",
        "u32"
      ],
      [
        "maxMemoryPages",
        "u32"
      ],
      [
        "enablePrintln",
        "bool"
      ],
      [
        "maxSubjectLen",
        "u32"
      ]
    ]
  },
  "SubId": "u32",
  "UncleEntryItem<BlockNumber, Hash, AccountId>": {
    "type": "enum",
    "value_list": [
      "InclusionHeight",
      "Uncle"
    ]
  },
  "ValidatorPrefs": {
    "type": "struct",
    "type_mapping": [
      [
        "commission",
        "Compact<Perbill>"
      ]
    ]
  },
  "VestingSchedule<Balance, BlockNumber>": {
    "type": "struct",
    "type_mapping": [
      [
        "offset",
        "Balance"
      ],
      [
        "perBlock",
        "Balance"
      ],
      [
        "startingBlock",
        "BlockNumber"
      ]
    ]
  },
  "Weight": "u64",
  "WeightMultiplier": "Fixed64",
  "WinningDataEntry": "Option<Bidder>",
  "WinningData": "[WinningDataEntry; 10]",
  "WithdrawReasons": {
    "type": "set",
    "value_type": "u64",
    "value_list": {
      "TransactionPayment": 1,
      "Transfer": 2,
      "Reserve": 4,
      "Fee": 8,
      "Tip": 16
    }
  },
  "Index": "u32",
  "Kind": "[u8; 16]",
  "Nominations": {
    "type": "struct",
    "type_mapping": [
      [
        "targets",
        "Vec<AccountId>"
      ],
      [
        "submittedIn",
        "EraIndex"
      ],
      [
        "suppressed",
        "bool"
      ]
    ]
  },
  "OpaqueTimeSlot": "Bytes",
  "Box<<T as Trait<I>>::Proposal>": "BoxProposal",
  "AuthoritySignature": "Signature",
  "<AuthorityId as RuntimeAppPublic>::Signature": "AuthoritySignature",
  "&[u8]": "Bytes",
  "Text": "Bytes",
  "Forcing": {
    "type": "enum",
    "value_list": [
      "NotForcing",
      "ForceNew",
      "ForceNone",
      "ForceAlways"
    ]
  },
  "Heartbeat": {
    "type": "struct",
    "type_mapping": [
      [
        "blockNumber",
        "BlockNumber"
      ],
      [
        "networkState",
        "OpaqueNetworkState"
      ],
      [
        "sessionIndex",
        "SessionIndex"
      ],
      [
        "authorityIndex",
        "AuthIndex"
      ],
      [
        "validatorsLen",
        "u32"
      ]
    ]
  },
  "RewardDestination": {
    "type": "enum",
    "type_mapping": [
      [
        "Staked",
        "Null"
      ],
      [
        "Stash",
        "Null"
      ],
      [
        "Controller",
        "Null"
      ],
      [
        "Account",
        "AccountId"
      ]
    ]
  },
  "RewardDestinationTo257": {
    "type": "enum",
    "value_list": [
      "Staked",
      "Stash",
      "Controller"
    ]
  },
  "ChangesTrieConfiguration": {
    "type": "struct",
    "type_mapping": [
      [
        "digestInterval",
        "u32"
      ],
      [
        "digestLevels",
        "u32"
      ]
    ]
  },
  "ConsensusEngineId": "GenericConsensusEngineId",
  "DigestItem": {
    "type": "enum",
    "type_mapping": [
      [
        "Other",
        "Bytes"
      ],
      [
        "AuthoritiesChange",
        "Vec<AuthorityId>"
      ],
      [
        "ChangesTrieRoot",
        "Hash"
      ],
      [
        "SealV0",
        "SealV0"
      ],
      [
        "Consensus",
        "Consensus"
      ],
      [
        "Seal",
        "Seal"
      ],
      [
        "PreRuntime",
        "PreRuntime"
      ]
    ]
  },
  "Digest": {
    "type": "struct",
    "type_mapping": [
      [
        "logs",
        "Vec<DigestItem>"
      ]
    ]
  },
  "DigestOf": "Digest",
  "SpanIndex": "u32",
  "slashing::SpanIndex": "SpanIndex",
  "SlashingSpans": {
    "type": "struct",
    "type_mapping": [
      [
        "spanIndex",
        "SpanIndex"
      ],
      [
        "lastStart",
        "EraIndex"
      ],
      [
        "lastNonzeroSlash",
        "EraIndex"
      ],
      [
        "prior",
        "Vec<EraIndex>"
      ]
    ]
  },
  "slashing::SlashingSpans": "SlashingSpans",
  "SpanRecord": {
    "type": "struct",
    "type_mapping": [
      [
        "slashed",
        "Balance"
      ],
      [
        "paidOut",
        "Balance"
      ]
    ]
  },
  "slashing::SpanRecord<BalanceOf>": "SpanRecord",
  "UnappliedSlashOther": {
    "type": "struct",
    "type_mapping": [
       ["account", "AccountId"],
       ["amount", "Balance"]
    ]
  },
  "UnappliedSlash<AccountId, BalanceOf>": {
    "type": "struct",
    "type_mapping": [
      [
        "validator",
        "AccountId"
      ],
      [
        "own",
        "AccountId"
      ],
      [
        "others",
        "Vec<UnappliedSlashOther>"
      ],
      [
        "reporters",
        "Vec<AccountId>"
      ],
      [
        "payout",
        "Balance"
      ]
    ]
  },
  "Keys": "SessionKeysSubstrate",
  "Header": {
    "type": "struct",
    "type_mapping": [
      [
        "parentHash",
        "Hash"
      ],
      [
        "number",
        "Compact<BlockNumber>"
      ],
      [
        "stateRoot",
        "Hash"
      ],
      [
        "extrinsicsRoot",
        "Hash"
      ],
      [
        "digest",
        "Digest"
      ]
    ]
  },
  "DispatchErrorModule": {
    "type": "struct",
    "type_mapping": [
      [
        "index",
        "u8"
      ],
      [
        "error",
        "u8"
      ]
    ]
  },
  "DispatchError": {
    "type": "enum",
    "type_mapping": [
      [
        "Other",
        "Null"
      ],
      [
        "CannotLookup",
        "Null"
      ],
      [
        "BadOrigin",
        "Null"
      ],
      [
        "Module",
        "DispatchErrorModule"
      ]
    ]
  },
  "DispatchResult": {
    "type": "enum",
    "type_mapping": [
      [
        "Ok",
        "Null"
      ],
      [
        "Error",
        "DispatchError"
      ]
    ]
  },
  "ActiveRecovery": {
    "type": "struct",
    "type_mapping": [
      [
        "created",
        "BlockNumber"
      ],
      [
        "deposit",
        "Balance"
      ],
      [
        "friends",
        "Vec<AccountId>"
      ]
    ]
  },
  "RecoveryConfig": {
    "type": "struct",
    "type_mapping": [
      [
        "delayPeriod",
        "BlockNumber"
      ],
      [
        "deposit",
        "Balance"
      ],
      [
        "friends",
        "Vec<AccountId>"
      ],
      [
        "threshold",
        "u16"
      ]
    ]
  },
  "BidKindVouch": {
    "type": "struct",
    "type_mapping": [
      [
        "account",
        "AccountId"
      ],
      [
        "amount",
        "Balance"
      ]
    ]
  },
  "BidKind": {
    "type": "enum",
    "type_mapping": [
      [
        "Deposit",
        "Balance"
      ],
      [
        "Vouch",
        "(AccountId, Balance)"
      ]
    ]
  },
  "BidKind<AccountId,Balance>": "Bidkind",
  "BidKind<AccountId, BalanceOf<T, I>>": "Bidkind",
  "Bid": {
    "type": "struct",
    "type_mapping": [
      [
        "who",
        "AccountId"
      ],
      [
        "kind",
        "BidKind"
      ],
      [
        "value",
        "Balance"
      ]
    ]
  },
  "StrikeCount": "u32",
  "VouchingStatus": {
    "type": "enum",
    "value_list": [
      "Vouching",
      "Banned"
    ]
  },
  "ExtrinsicMetadata": {
    "type": "struct",
    "type_mapping": [
      [
        "version",
        "u8"
      ],
      [
        "signedExtensions",
        "Vec<Bytes>"
      ]
    ]
  },
  "RewardPoint": "u32",
  "BTreeMap<AccountId, RewardPoint>": "Vec<(AccountId, RewardPoint)>",
  "EraRewardPoints": {
    "type": "struct",
    "type_mapping": [
      [
        "total",
        "RewardPoint"
      ],
      [
        "individual",
        "BTreeMap<AccountId, RewardPoint>"
      ]
    ]
  },
  "IncomingParachainDeploy": {
    "type": "struct",
    "type_mapping": [
      [
        "code",
        "ValidationCode"
      ],
      [
        "initialHeadData",
        "HeadData"
      ]
    ]
  },
  "NewBidder": {
    "type": "struct",
    "type_mapping": [
      [
        "who",
        "AccountId"
      ],
      [
        "sub",
        "SubId"
      ]
    ]
  },
  "IncomingParachainFixed": {
    "type": "struct",
    "type_mapping": [
      [
        "codeHash",
        "Hash"
      ],
      [
        "codeSize",
        "u32"
      ],
      [
        "initialHeadData",
        "HeadData"
      ]
    ]
  },
  "IncomingParachain": {
    "type": "enum",
    "type_mapping": [
      [
        "Unset",
        "NewBidder"
      ],
      [
        "Fixed",
        "IncomingParachainFixed"
      ],
      [
        "Deploy",
        "IncomingParachainDeploy"
      ]
    ]
  },
  "LastRuntimeUpgradeInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "specVersion",
        "Compact<u32>"
      ],
      [
        "specName",
        "Text"
      ]
    ]
  },
  "ProxyState": {
    "type": "enum",
    "type_mapping": [
      [
        "Open",
        "AccountId"
      ],
      [
        "Active",
        "AccountId"
      ]
    ]
  },
  "ReleasesBalances": {
    "type": "enum",
    "value_list": [
      "V1_0_0",
      "V2_0_0"
    ]
  },
  "Releases": {
    "type": "enum",
    "value_list": [
      "V1",
      "V2",
      "V3",
      "V4",
      "V5",
      "V6",
      "V7",
      "V8",
      "V9",
      "V10"
    ]
  },
  "SlotRange": {
    "type": "enum",
    "value_list": [
      "ZeroZero",
      "ZeroOne",
      "ZeroTwo",
      "ZeroThree",
      "OneOne",
      "OneTwo",
      "OneThree",
      "TwoTwo",
      "TwoThree",
      "ThreeThree"
    ]
  },
  "ValidityAttestation": {
    "type": "enum",
    "type_mapping": [
      [
        "Never",
        "Null"
      ],
      [
        "Implicit",
        "ValidatorSignature"
      ],
      [
        "Explicit",
        "ValidatorSignature"
      ]
    ]
  },
  "VestingInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "locked",
        "Balance"
      ],
      [
        "perBlock",
        "Balance"
      ],
      [
        "startingBlock",
        "BlockNumber"
      ]
    ]
  },
  "NominatorIndex": "u32",
  "ValidatorIndex": "u16",
  "PerU16": "u16",
  "ValidatorIndexCompact": "Compact<ValidatorIndex>",
  "NominatorIndexCompact": "Compact<NominatorIndex>",
  "OffchainAccuracy": "PerU16",
  "OffchainAccuracyCompact": "Compact<OffchainAccuracy>",
  "CompactScoreCompact": {
    "type": "struct",
      "type_mapping": [
        ["validatorIndex", "ValidatorIndexCompact"],
        ["offchainAccuracy", "OffchainAccuracyCompact"]
      ]
  },
  "CompactScore": {
    "type": "struct",
      "type_mapping": [
        ["validatorIndex", "ValidatorIndex"],
        ["offchainAccuracy", "OffchainAccuracy"]
      ]
  },
  "CompactAssignmentsFrom258": {
    "type": "struct",
    "type_mapping": [
      [
        "votes1",
        "Vec<(NominatorIndexCompact, ValidatorIndexCompact)>"
      ],
      [
        "votes2",
        "Vec<(NominatorIndexCompact, CompactScoreCompact, ValidatorIndexCompact)>"
      ],
      [
        "votes3",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 2], ValidatorIndexCompact)>"
      ],
      [
        "votes4",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 3], ValidatorIndexCompact)>"
      ],
      [
        "votes5",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 4], ValidatorIndexCompact)>"
      ],
      [
        "votes6",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 5], ValidatorIndexCompact)>"
      ],
      [
        "votes7",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 6], ValidatorIndexCompact)>"
      ],
      [
        "votes8",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 7], ValidatorIndexCompact)>"
      ],
      [
        "votes9",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 8], ValidatorIndexCompact)>"
      ],
      [
        "votes10",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 9], ValidatorIndexCompact)>"
      ],
      [
        "votes11",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 10], ValidatorIndexCompact)>"
      ],
      [
        "votes12",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 11], ValidatorIndexCompact)>"
      ],
      [
        "votes13",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 12], ValidatorIndexCompact)>"
      ],
      [
        "votes14",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 13], ValidatorIndexCompact)>"
      ],
      [
        "votes15",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 14], ValidatorIndexCompact)>"
      ],
      [
        "votes16",
        "Vec<(NominatorIndexCompact, [CompactScoreCompact; 15], ValidatorIndexCompact)>"
      ]
    ]
  },
  "CompactAssignmentsTo257": {
    "type": "struct",
    "type_mapping": [
      [
        "votes1",
        "Vec<(NominatorIndex, [CompactScore; 0], ValidatorIndex)>"
      ],
      [
        "votes2",
        "Vec<(NominatorIndex, [CompactScore; 1], ValidatorIndex)>"
      ],
      [
        "votes3",
        "Vec<(NominatorIndex, [CompactScore; 2], ValidatorIndex)>"
      ],
      [
        "votes4",
        "Vec<(NominatorIndex, [CompactScore; 3], ValidatorIndex)>"
      ],
      [
        "votes5",
        "Vec<(NominatorIndex, [CompactScore; 4], ValidatorIndex)>"
      ],
      [
        "votes6",
        "Vec<(NominatorIndex, [CompactScore; 5], ValidatorIndex)>"
      ],
      [
        "votes7",
        "Vec<(NominatorIndex, [CompactScore; 6], ValidatorIndex)>"
      ],
      [
        "votes8",
        "Vec<(NominatorIndex, [CompactScore; 7], ValidatorIndex)>"
      ],
      [
        "votes9",
        "Vec<(NominatorIndex, [CompactScore; 8], ValidatorIndex)>"
      ],
      [
        "votes10",
        "Vec<(NominatorIndex, [CompactScore; 9], ValidatorIndex)>"
      ],
      [
        "votes11",
        "Vec<(NominatorIndex, [CompactScore; 10], ValidatorIndex)>"
      ],
      [
        "votes12",
        "Vec<(NominatorIndex, [CompactScore; 11], ValidatorIndex)>"
      ],
      [
        "votes13",
        "Vec<(NominatorIndex, [CompactScore; 12], ValidatorIndex)>"
      ],
      [
        "votes14",
        "Vec<(NominatorIndex, [CompactScore; 13], ValidatorIndex)>"
      ],
      [
        "votes15",
        "Vec<(NominatorIndex, [CompactScore; 14], ValidatorIndex)>"
      ],
      [
        "votes16",
        "Vec<(NominatorIndex, [CompactScore; 15], ValidatorIndex)>"
      ]
    ]
  },
  "CompactAssignments": "CompactAssignmentsTo257",
  "DeferredOffenceOf": {
    "type": "struct",
      "type_mapping": [
        ["offences", "Vec<OffenceDetails>"],
        ["perc", "Vec<Perbill>"],
        ["session", "SessionIndex"]
      ]
  },
  "Statement": {
    "type": "enum",
    "type_mapping": [
      [
        "Never",
        "Null"
      ],
      [
        "Candidate",
        "Hash"
      ],
      [
        "Valid",
        "Hash"
      ],
      [
        "Invalid",
        "Hash"
      ]
    ]
  },
  "ValidatorSignature": "Signature",
  "DoubleVoteReportStatement": {
    "type": "struct",
    "type_mapping": [
      [
        "statement",
        "Statement"
      ],
      [
        "signature",
        "ValidatorSignature"
      ]
    ]
  },
  "DoubleVoteReportProof": {
    "type": "struct",
    "type_mapping": [
      [
        "session",
        "SessionIndex"
      ],
      [
        "trieNodes",
        "Vec<Bytes>"
      ]
    ]
  },
  "SigningContext": {
    "type": "struct",
    "type_mapping": [
      [
        "sessionIndex",
        "SessionIndex"
      ],
      [
        "parentHash",
        "Hash"
      ]
    ]
  },
  "DoubleVoteReport": {
    "type": "struct",
    "type_mapping": [
      [
        "identity",
        "ValidatorId"
      ],
      [
        "first",
        "(Statement, ValidatorSignature)"
      ],
      [
        "second",
        "(Statement, ValidatorSignature)"
      ],
      [
        "proof",
        "MembershipProof"
      ],
      [
        "signingContext",
        "SigningContext"
      ]
    ]
  },
  "ElectionCompute": {
    "type": "enum",
    "value_list": [
      "OnChain",
      "Signed",
      "Authority"
    ]
  },
  "ElectionResult": {
    "type": "struct",
    "type_mapping": [
      [
        "compute",
        "ElectionCompute"
      ],
      [
        "slotStake",
        "Balance"
      ],
      [
        "electedStashes",
        "Vec<AccountId>"
      ],
      [
        "exposures",
        "Vec<(AccountId, Exposure)>"
      ]
    ]
  },
  "ElectionStatus": {
    "type": "enum",
    "type_mapping": [
      [
        "Close",
        "Null"
      ],
      [
        "Open",
        "BlockNumber"
      ]
    ]
  },
  "Phase": {
    "type": "enum",
    "type_mapping": [
      [
        "ApplyExtrinsic",
        "u32"
      ],
      [
        "Finalization",
        "Null"
      ],
      [
        "Initialization",
        "Null"
      ]
    ]
  },
  "PhragmenScore": "[u128; 3]",
  "PreimageStatusAvailable": {
    "type": "struct",
    "type_mapping": [
      [
        "data",
        "Bytes"
      ],
      [
        "provider",
        "AccountId"
      ],
      [
        "deposit",
        "Balance"
      ],
      [
        "since",
        "BlockNumber"
      ],
      [
        "expiry",
        "Option<BlockNumber>"
      ]
    ]
  },
  "PreimageStatus": {
    "type": "enum",
    "type_mapping": [
      [
        "Missing",
        "BlockNumber"
      ],
      [
        "Available",
        "PreimageStatusAvailable"
      ]
    ]
  },
  "Randomness": "Hash",
  "MaybeRandomness": "Option<Randomness>",
  "schnorrkel::Randomness": "Hash",
  "schnorrkel::RawVRFOutput": "[u8; 32]",
  "TaskAddress": {
    "type": "struct",
    "type_mapping": [
      ["blockNumber", "BlockNumber"],
      ["index", "u32"]
    ]
  },
  "ValidationFunctionParams": {
    "type": "struct",
    "type_mapping": [
      [
        "maxCodeSize",
        "u32"
      ],
      [
        "relayChainHeight",
        "RelayChainBlockNumber"
      ],
      [
        "codeUpgradeAllowed",
        "Option<RelayChainBlockNumber>"
      ]
    ]
  },
  "ValidationCode": "Bytes",
  "ParaPastCodeMeta": {
    "type": "struct",
    "type_mapping": [
      [
        "upgradeTimes",
        "Vec<BlockNumber>"
      ],
      [
        "lastPruned",
        "Option<BlockNumber>"
      ]
    ]
  },
  "ModuleId": "LockIdentifier",
  "RuntimeDbWeight": {
    "type": "struct",
    "type_mapping": [
      [
        "read",
        "Weight"
      ],
      [
        "write",
        "Weight"
      ]
    ]
  },
  "Renouncing": {
    "type": "enum",
    "type_mapping": [
      [
        "Member",
        "Null"
      ],
      [
        "RunnerUp",
        "Null"
      ],
      [
        "Candidate",
        "Compact<u32>"
      ]
    ]
  },
  "ExtrinsicsWeight": {
    "type": "struct",
    "type_mapping": [
      [
        "normal",
        "Weight"
      ],
      [
        "operational",
        "Weight"
      ]
    ]
  },
  "weights::ExtrinsicsWeight": "ExtrinsicsWeight",
  "ValidatorCount": "u32",
  "MembershipProof": {
    "type": "struct",
    "type_mapping": [
      [
        "session",
        "SessionIndex"
      ],
      [
        "trieNodes",
        "Vec<Vec<u8>>"
      ],
      [
        "validatorCount",
        "ValidatorCount"
      ]
    ]
  },
  "JustificationNotification": "Bytes",
  "KeyOwnerProof": "MembershipProof",
  "DefunctVoter": {
    "type": "struct",
    "type_mapping": [
      [
        "who",
        "AccountId"
      ],
      [
        "voteCount",
        "Compact<u32>"
      ],
      [
        "candidateCount",
        "Compact<u32>"
      ]
    ]
  },
  "ElectionScore": "[u128; 3]",
  "ElectionSize": {
    "type": "struct",
    "type_mapping": [
      [
        "validators",
        "Compact<ValidatorIndex>"
      ],
      [
        "nominators",
        "Compact<NominatorIndex>"
      ]
    ]
  },
  "AllowedSlots": {
    "type": "enum",
    "value_list": [
      "PrimarySlots",
      "PrimaryAndSecondaryPlainSlots",
      "PrimaryAndSecondaryVRFSlots"
    ]
  },
  "NextConfigDescriptorV1": {
    "type": "struct",
    "type_mapping": [
      [
        "c",
        "(u64, u64)"
      ],
      [
        "allowedSlots",
        "AllowedSlots"
      ]
    ]
  },
  "NextConfigDescriptor": {
    "type": "enum",
    "type_mapping": [
      [
        "V0",
        "Null"
      ],
      [
        "V1",
        "NextConfigDescriptorV1"
      ]
    ]
  },
  "StatementKind": {
    "type": "enum",
    "value_list": [
      "Regular",
      "Saft"
    ]
  },
  "schedule::Priority": "u8",
  "GrandpaEquivocation": {
    "type": "enum",
    "type_mapping": [
      [
        "Prevote",
        "GrandpaEquivocationValue"
      ],
      [
        "Precommit",
        "GrandpaEquivocationValue"
      ]
    ]
  },
  "GrandpaPrevote": {
    "type": "struct",
    "type_mapping": [
      [
        "targetHash",
        "Hash"
      ],
      [
        "targetNumber",
        "BlockNumber"
      ]
    ]
  },
  "Equivocation": "GrandpaEquivocation",
  "EquivocationProof": {
    "type": "struct",
    "type_mapping": [
      [
        "setId",
        "SetId"
      ],
      [
        "equivocation",
        "Equivocation"
      ]
    ]
  },
  "ProxyType": {
    "type": "enum",
    "value_list": [
      "Any",
      "NonTransfer",
      "Governance",
      "Staking"
    ]
  },
  "BalanceStatus": {
    "type": "enum",
    "value_list": [
      "Free",
      "Reserved"
    ]
  },
  "Status": "BalanceStatus",
  "EcdsaSignature": "[u8; 65]",
  "Ed25519Signature": "H512",
  "Sr25519Signature": "H512",
  "MultiSignature": {
    "type": "enum",
    "type_mapping": [
      [
        "Ed25519",
        "Ed25519Signature"
      ],
      [
        "Sr25519",
        "Sr25519Signature"
      ],
      [
        "Ecdsa",
        "EcdsaSignature"
      ]
    ]
  },
  "schedule::period<blocknumber>": "(BlockNumber, u32)",
  "OpaqueCall": "OpaqueCall",
  "AuthorityId": "AccountId",
  "RawVRFOutput": "[u8; 32]",
  "BlockAttestations": {
    "type": "struct",
    "type_mapping": [
      [
        "receipt",
        "CandidateReceipt"
      ],
      [
        "valid",
        "Vec<AccountId>"
      ],
      [
        "invalid",
        "Vec<AccountId>"
      ]
    ]
  },
  "IncludedBlocks": {
    "type": "struct",
    "type_mapping": [
      [
        "actualNumber",
        "BlockNumber"
      ],
      [
        "session",
        "SessionIndex"
      ],
      [
        "randomSeed",
        "H256"
      ],
      [
        "activeParachains",
        "Vec<ParaId>"
      ],
      [
        "paraBlocks",
        "Vec<Hash>"
      ]
    ]
  },
  "HeartbeatTo244": {
    "type": "struct",
    "type_mapping": [
      [
        "blockNumber",
        "BlockNumber"
      ],
      [
        "networkState",
        "OpaqueNetworkState"
      ],
      [
        "sessionIndex",
        "SessionIndex"
      ],
      [
        "authorityIndex",
        "AuthIndex"
      ]
    ]
  },
  "OpaqueMultiaddr": "Bytes",
  "OpaquePeerId": "Bytes",
  "OpaqueNetworkState": {
    "type": "struct",
    "type_mapping": [
      [
        "peerId",
        "OpaquePeerId"
      ],
      [
        "externalAddresses",
        "Vec<OpaqueMultiaddr>"
      ]
    ]
  },
  "ProposalIndex": "u32",
  "VotesTo230": {
    "type": "struct",
    "type_mapping": [
      [
        "index",
        "ProposalIndex"
      ],
      [
        "threshold",
        "MemberCount"
      ],
      [
        "ayes",
        "Vec<AccountId>"
      ],
      [
        "nays",
        "Vec<AccountId>"
      ]
    ]
  },
  "Votes": {
    "type": "struct",
    "type_mapping": [
      [
        "index",
        "ProposalIndex"
      ],
      [
        "threshold",
        "MemberCount"
      ],
      [
        "ayes",
        "Vec<AccountId>"
      ],
      [
        "nays",
        "Vec<AccountId>"
      ],
      [
        "end",
        "BlockNumber"
      ]
    ]
  },
  "RuntimeDispatchInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "weight",
        "Weight"
      ],
      [
        "class",
        "DispatchClass"
      ],
      [
        "partialFee",
        "Balance"
      ]
    ]
  },
  "AliveContractInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "trieId",
        "TrieId"
      ],
      [
        "storageSize",
        "u32"
      ],
      [
        "codeHash",
        "CodeHash"
      ],
      [
        "rentAllowance",
        "Balance"
      ],
      [
        "deductBlock",
        "BlockNumber"
      ],
      [
        "lastWrite",
        "Option<BlockNumber>"
      ]
    ]
  },
  "CodeHash": "Hash",
  "ContractCallRequest": {
    "type": "struct",
    "type_mapping": [
      [
        "origin",
        "AccountId"
      ],
      [
        "dest",
        "AccountId"
      ],
      [
        "value",
        "Balance"
      ],
      [
        "gasLimit",
        "u64"
      ],
      [
        "inputData",
        "Bytes"
      ]
    ]
  },
  "ContractExecResultSuccess": {
    "type": "struct",
    "type_mapping": [
      [
        "flags",
        "u32"
      ],
      [
        "data",
        "Vec<u8>"
      ],
      [
        "gasConsumed",
        "u64"
      ]
    ]
  },
  "ContractExecResult": {
    "type": "enum",
    "type_mapping": [
      [
        "Success",
        "ContractExecResultSuccess"
      ],
      [
        "Error",
        "Null"
      ]
    ]
  },
  "ContractStorageKey": "[u8; 32]",
  "PrefabWasmModule": {
    "type": "struct",
    "type_mapping": [
      [
        "scheduleVersion",
        "Compact<u32>"
      ],
      [
        "initial",
        "Compact<u32>"
      ],
      [
        "maximum",
        "Compact<u32>"
      ],
      [
        "_reserved",
        "PrefabWasmModuleReserved"
      ],
      [
        "code",
        "Bytes"
      ]
    ]
  },
  "PrefabWasmModuleReserved": "Option<Null>",
  "ScheduleTo212": {
    "type": "struct",
    "type_mapping": [
      [
        "version",
        "u32"
      ],
      [
        "putCodePerByteCost",
        "Gas"
      ],
      [
        "growMemCost",
        "Gas"
      ],
      [
        "regularOpCost",
        "Gas"
      ],
      [
        "returnDataPerByteCost",
        "Gas"
      ],
      [
        "eventDataPerByteCost",
        "Gas"
      ],
      [
        "eventPerTopicCost",
        "Gas"
      ],
      [
        "eventBaseCost",
        "Gas"
      ],
      [
        "sandboxDataReadCost",
        "Gas"
      ],
      [
        "sandboxDataWriteCost",
        "Gas"
      ],
      [
        "maxEventTopics",
        "u32"
      ],
      [
        "maxStackHeight",
        "u32"
      ],
      [
        "maxMemoryPages",
        "u32"
      ],
      [
        "enablePrintln",
        "bool"
      ],
      [
        "maxSubjectLen",
        "u32"
      ]
    ]
  },
  "SeedOf": "Hash",
  "TombstoneContractInfo": "Hash",
  "ExtrinsicOrHash": {
    "type": "enum",
    "type_mapping": [
      [
        "Hash",
        "Hash"
      ],
      [
        "Extrinsic",
        "Bytes"
      ]
    ]
  },
  "ExtrinsicStatus": {
    "type": "enum",
    "type_mapping": [
      [
        "Future",
        "Null"
      ],
      [
        "Ready",
        "Null"
      ],
      [
        "Broadcast",
        "Vec<Text>"
      ],
      [
        "InBlock",
        "Hash"
      ],
      [
        "Retracted",
        "Hash"
      ],
      [
        "FinalityTimeout",
        "Hash"
      ],
      [
        "Finalized",
        "Hash"
      ],
      [
        "Usurped",
        "Hash"
      ],
      [
        "Dropped",
        "Null"
      ],
      [
        "Invalid",
        "Null"
      ]
    ]
  },
  "StorageKey": "Bytes",
  "PrefixedStorageKey": "StorageKey",
  "AccountIndex": "GenericAccountIndex",
  "Address": "GenericAddress",
  "AssetId": "u32",
  "Justification": "Bytes",
  "StorageData": "Bytes",
  "KeyValue": {
    "type": "struct",
    "type_mapping": [
      [
        "key",
        "StorageKey"
      ],
      [
        "value",
        "StorageData"
      ]
    ]
  },
  "KeyTypeId": "u32",
  "LookupSource": "Address",
  "LookupTarget": "AccountId",
  "Perbill": "u32",
  "Permill": "u32",
  "Perquintill": "u64",
  "Phantom": "Null",
  "SignedBlock": {
    "type": "struct",
    "type_mapping": [
      [
        "block",
        "Block"
      ],
      [
        "justification",
        "Justification"
      ]
    ]
  },
  "ValidatorId": "AccountId",
  "PreRuntime": "(ConsensusEngineId, Bytes)",
  "SealV0": "(u64, Signature)",
  "Seal": "(ConsensusEngineId, Bytes)",
  "Consensus": "(ConsensusEngineId, Bytes)",
  "Period": "(BlockNumber, u32)",
  "Priority": "u8",
  "SchedulePeriod": "Period",
  "SchedulePriority": "Priority",
  "Scheduled": {
    "type": "struct",
    "type_mapping": [
      [
        "maybeId",
        "Option<Bytes>"
      ],
      [
        "priority",
        "SchedulePriority"
      ],
      [
        "call",
        "Call"
      ],
      [
        "maybePeriodic",
        "Option<SchedulePeriod>"
      ]
    ]
  },
  "SocietyJudgement": {
    "type": "enum",
    "value_list": [
      "Rebid",
      "Reject",
      "Approve"
    ]
  },
  "SocietyVote": {
    "type": "enum",
    "value_list": [
      "Skeptic",
      "Reject",
      "Approve"
    ]
  },
  "BlockHash": "Hash",
  "UncleEntryItem": {
    "type": "enum",
    "type_mapping": [
      [
        "InclusionHeight",
        "BlockNumber"
      ],
      [
        "Uncle",
        "(Hash, Option<AccountId>)"
      ]
    ]
  },
  "ApiId": "[u8; 8]",
  "KeyValueOption": "(StorageKey, Option<StorageData>)",
  "ReadProof": {
    "type": "struct",
    "type_mapping": [
      [
        "at",
        "Hash"
      ],
      [
        "proof",
        "Vec<Bytes>"
      ]
    ]
  },
  "RuntimeVersionApi": "(ApiId, u32)",
  "RuntimeVersion": {
    "type": "struct",
    "type_mapping": [
      [
        "specName",
        "Text"
      ],
      [
        "implName",
        "Text"
      ],
      [
        "authoringVersion",
        "u32"
      ],
      [
        "specVersion",
        "u32"
      ],
      [
        "implVersion",
        "u32"
      ],
      [
        "apis",
        "Vec<RuntimeVersionApi>"
      ],
      [
        "transactionVersion",
        "u32"
      ]
    ]
  },
  "StorageChangeSet": {
    "type": "struct",
    "type_mapping": [
      [
        "block",
        "Hash"
      ],
      [
        "changes",
        "Vec<KeyValueOption>"
      ]
    ]
  },
  "GrandpaEquivocationProof": {
    "type": "struct",
    "type_mapping": [
      [
        "setId",
        "SetId"
      ],
      [
        "equivocation",
        "GrandpaEquivocation"
      ]
    ]
  },
  "GrandpaEquivocationValue": {
    "type": "struct",
    "type_mapping": [
      [
        "roundNumber",
        "u64"
      ],
      [
        "identity",
        "AuthorityId"
      ],
      [
        "first",
        "(GrandpaPrevote, AuthoritySignature)"
      ],
      [
        "second",
        "(GrandpaPrevote, AuthoritySignature)"
      ]
    ]
  },
  "PendingPause": {
    "type": "struct",
    "type_mapping": [
      [
        "scheduledAt",
        "BlockNumber"
      ],
      [
        "delay",
        "BlockNumber"
      ]
    ]
  },
  "PendingResume": {
    "type": "struct",
    "type_mapping": [
      [
        "scheduledAt",
        "BlockNumber"
      ],
      [
        "delay",
        "BlockNumber"
      ]
    ]
  },
  "Precommits": {
    "type": "struct",
    "type_mapping": [
      [
        "currentWeight",
        "u32"
      ],
      [
        "missing",
        "BTreeSet<AuthorityId>"
      ]
    ]
  },
  "Prevotes": {
    "type": "struct",
    "type_mapping": [
      [
        "currentWeight",
        "u32"
      ],
      [
        "missing",
        "BTreeSet<AuthorityId>"
      ]
    ]
  },
  "ReportedRoundStates": {
    "type": "struct",
    "type_mapping": [
      [
        "setId",
        "u32"
      ],
      [
        "best",
        "RoundState"
      ],
      [
        "background",
        "Vec<RoundState>"
      ]
    ]
  },
  "RoundState": {
    "type": "struct",
    "type_mapping": [
      [
        "round",
        "u32"
      ],
      [
        "totalWeight",
        "u32"
      ],
      [
        "thresholdWeight",
        "u32"
      ],
      [
        "prevotes",
        "Prevotes"
      ],
      [
        "precommits",
        "Precommits"
      ]
    ]
  },
  "StoredPendingChange": {
    "type": "struct",
    "type_mapping": [
      [
        "scheduledAt",
        "BlockNumber"
      ],
      [
        "delay",
        "BlockNumber"
      ],
      [
        "nextAuthorities",
        "AuthorityList"
      ]
    ]
  },
  "StoredState": {
    "type": "enum",
    "type_mapping": [
      [
        "Live",
        "Null"
      ],
      [
        "PendingPause",
        "PendingPause"
      ],
      [
        "Paused",
        "Null"
      ],
      [
        "PendingResume",
        "PendingResume"
      ]
    ]
  },
  "AccountInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "nonce",
        "Index"
      ],
      [
        "refcount",
        "RefCount"
      ],
      [
        "data",
        "AccountData"
      ]
    ]
  },
  "ChainProperties": {
    "type": "struct",
    "type_mapping": [
      [
        "ss58Format",
        "Option<u8>"
      ],
      [
        "tokenDecimals",
        "Option<u32>"
      ],
      [
        "tokenSymbol",
        "Option<Text>"
      ]
    ]
  },
  "ChainType": {
    "type": "enum",
    "type_mapping": [
      [
        "Development",
        "Null"
      ],
      [
        "Local",
        "Null"
      ],
      [
        "Live",
        "Null"
      ],
      [
        "Custom",
        "Text"
      ]
    ]
  },
  "DispatchErrorTo198": {
    "type": "struct",
    "type_mapping": [
      [
        "module",
        "Option<u8>"
      ],
      [
        "error",
        "u8"
      ]
    ]
  },
  "DispatchInfoTo190": {
    "type": "struct",
    "type_mapping": [
      [
        "weight",
        "Weight"
      ],
      [
        "class",
        "DispatchClass"
      ]
    ]
  },
  "DispatchInfoTo244": {
    "type": "struct",
    "type_mapping": [
      [
        "weight",
        "Weight"
      ],
      [
        "class",
        "DispatchClass"
      ],
      [
        "paysFee",
        "bool"
      ]
    ]
  },
  "DispatchResultOf": "DispatchResult",
  "Event": "GenericEvent",
  "EventId": "[u8; 2]",
  "EventRecord": "EventRecord",
  "EventRecordTo76": {
    "type": "struct",
    "type_mapping": [
      [
        "phase",
        "Phase"
      ],
      [
        "event",
        "Event"
      ]
    ]
  },
  "Health": {
    "type": "struct",
    "type_mapping": [
      [
        "peers",
        "u64"
      ],
      [
        "isSyncing",
        "bool"
      ],
      [
        "shouldHavePeers",
        "bool"
      ]
    ]
  },
  "InvalidTransaction": {
    "type": "enum",
    "type_mapping": [
      [
        "Call",
        "Null"
      ],
      [
        "Payment",
        "Null"
      ],
      [
        "Future",
        "Null"
      ],
      [
        "Stale",
        "Null"
      ],
      [
        "BadProof",
        "Null"
      ],
      [
        "AncientBirthBlock",
        "Null"
      ],
      [
        "ExhaustsResources",
        "Null"
      ],
      [
        "Custom",
        "u8"
      ],
      [
        "BadMandatory",
        "Null"
      ],
      [
        "MandatoryDispatch",
        "Null"
      ]
    ]
  },
  "Key": "Bytes",
  "NetworkState": {
    "type": "struct",
    "type_mapping": [
      [
        "peerId",
        "Text"
      ],
      [
        "listenedAddresses",
        "Vec<Text>"
      ],
      [
        "externalAddresses",
        "Vec<Text>"
      ],
      [
        "connectedPeers",
        "HashMap<Text, Peer>"
      ],
      [
        "notConnectedPeers",
        "HashMap<Text, NotConnectedPeer>"
      ],
      [
        "averageDownloadPerSec",
        "u64"
      ],
      [
        "averageUploadPerSec",
        "u64"
      ],
      [
        "peerset",
        "NetworkStatePeerset"
      ]
    ]
  },
  "NetworkStatePeerset": {
    "type": "struct",
    "type_mapping": [
      [
        "messageQueue",
        "u64"
      ],
      [
        "nodes",
        "HashMap<Text, NetworkStatePeersetInfo>"
      ]
    ]
  },
  "NetworkStatePeersetInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "connected",
        "bool"
      ],
      [
        "reputation",
        "i32"
      ]
    ]
  },
  "NodeRole": {
    "type": "enum",
    "type_mapping": [
      [
        "Full",
        "Null"
      ],
      [
        "LightClient",
        "Null"
      ],
      [
        "Authority",
        "Null"
      ],
      [
        "UnknownRole",
        "u8"
      ]
    ]
  },
  "NotConnectedPeer": {
    "type": "struct",
    "type_mapping": [
      [
        "knownAddresses",
        "Vec<Text>"
      ],
      [
        "latestPingTime",
        "Option<PeerPing>"
      ],
      [
        "versionString",
        "Option<Text>"
      ]
    ]
  },
  "Peer": {
    "type": "struct",
    "type_mapping": [
      [
        "enabled",
        "bool"
      ],
      [
        "endpoint",
        "PeerEndpoint"
      ],
      [
        "knownAddresses",
        "Vec<Text>"
      ],
      [
        "latestPingTime",
        "PeerPing"
      ],
      [
        "open",
        "bool"
      ],
      [
        "versionString",
        "Text"
      ]
    ]
  },
  "PeerEndpoint": {
    "type": "struct",
    "type_mapping": [
      [
        "listening",
        "PeerEndpointAddr"
      ]
    ]
  },
  "PeerEndpointAddr": {
    "type": "struct",
    "type_mapping": [
      [
        "_alias",
        {
          "localAddr": "local_addr",
          "sendBackAddr": "send_back_addr"
        }
      ],
      [
        "localAddr",
        "Text"
      ],
      [
        "sendBackAddr",
        "Text"
      ]
    ]
  },
  "PeerPing": {
    "type": "struct",
    "type_mapping": [
      [
        "nanos",
        "u64"
      ],
      [
        "secs",
        "u64"
      ]
    ]
  },
  "PeerInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "peerId",
        "Text"
      ],
      [
        "roles",
        "Text"
      ],
      [
        "protocolVersion",
        "u32"
      ],
      [
        "bestHash",
        "Hash"
      ],
      [
        "bestNumber",
        "BlockNumber"
      ]
    ]
  },
  "TransactionValidityError": {
    "type": "enum",
    "type_mapping": [
      [
        "Invalid",
        "InvalidTransaction"
      ],
      [
        "Unknown",
        "UnknownTransaction"
      ]
    ]
  },
  "UnknownTransaction": {
    "type": "enum",
    "type_mapping": [
      [
        "CannotLookup",
        "Null"
      ],
      [
        "NoUnsignedValidator",
        "Null"
      ],
      [
        "Custom",
        "u8"
      ]
    ]
  },
  "WeightToFeeCoefficient": {
    "type": "struct",
    "type_mapping": [
      [
        "coeffInteger",
        "Balance"
      ],
      [
        "coeffFrac",
        "Perbill"
      ],
      [
        "negative",
        "bool"
      ],
      [
        "degree",
        "u8"
      ]
    ]
  },
  "EraIndex": "u32",
  "EraRewards": {
    "type": "struct",
    "type_mapping": [
      [
        "total",
        "u32"
      ],
      [
        "rewards",
        "Vec<u32>"
      ]
    ]
  },
  "Exposure": {
    "type": "struct",
    "type_mapping": [
      [
        "total",
        "Compact<Balance>"
      ],
      [
        "own",
        "Compact<Balance>"
      ],
      [
        "others",
        "Vec<IndividualExposure>"
      ]
    ]
  },
  "IndividualExposure": {
    "type": "struct",
    "type_mapping": [
      [
        "who",
        "AccountId"
      ],
      [
        "value",
        "Compact<Balance>"
      ]
    ]
  },
  "KeyType": "AccountId",
  "Points": "u32",
  "SlashJournalEntry": {
    "type": "struct",
    "type_mapping": [
      [
        "who",
        "AccountId"
      ],
      [
        "amount",
        "Balance"
      ],
      [
        "ownSlash",
        "Balance"
      ]
    ]
  },
  "SlashingSpansTo204": {
    "type": "struct",
    "type_mapping": [
      [
        "spanIndex",
        "SpanIndex"
      ],
      [
        "lastStart",
        "EraIndex"
      ],
      [
        "prior",
        "Vec<EraIndex>"
      ]
    ]
  },
  "StakingLedgerTo223": {
    "type": "struct",
    "type_mapping": [
      [
        "stash",
        "AccountId"
      ],
      [
        "total",
        "Compact<Balance>"
      ],
      [
        "active",
        "Compact<Balance>"
      ],
      [
        "unlocking",
        "Vec<UnlockChunk>"
      ]
    ]
  },
  "StakingLedgerTo240": {
    "type": "struct",
    "type_mapping": [
      [
        "stash",
        "AccountId"
      ],
      [
        "total",
        "Compact<Balance>"
      ],
      [
        "active",
        "Compact<Balance>"
      ],
      [
        "unlocking",
        "Vec<UnlockChunk>"
      ],
      [
        "lastReward",
        "Option<EraIndex>"
      ]
    ]
  },
  "StakingLedger": {
    "type": "struct",
    "type_mapping": [
      [
        "stash",
        "AccountId"
      ],
      [
        "total",
        "Compact<Balance>"
      ],
      [
        "active",
        "Compact<Balance>"
      ],
      [
        "unlocking",
        "Vec<UnlockChunk>"
      ],
      [
        "claimedRewards",
        "Vec<EraIndex>"
      ]
    ]
  },
  "UnappliedSlash": {
    "type": "struct",
    "type_mapping": [
      [
        "validator",
        "AccountId"
      ],
      [
        "own",
        "Balance"
      ],
      [
        "others",
        "Vec<UnappliedSlashOther>"
      ],
      [
        "reporters",
        "Vec<AccountId>"
      ],
      [
        "payout",
        "Balance"
      ]
    ]
  },
  "UnlockChunk": {
    "type": "struct",
    "type_mapping": [
      [
        "value",
        "Compact<Balance>"
      ],
      [
        "era",
        "Compact<BlockNumber>"
      ]
    ]
  },
  "ValidatorPrefsTo196": {
    "type": "struct",
    "type_mapping": [
      [
        "validatorPayment",
        "Compact<Balance>"
      ]
    ]
  },
  "ValidatorPrefsTo145": {
    "type": "struct",
    "type_mapping": [
      [
        "unstakeThreshold",
        "Compact<u32>"
      ],
      [
        "validatorPayment",
        "Compact<Balance>"
      ]
    ]
  },
  "BalanceLockTo212": {
    "type": "struct",
    "type_mapping": [
      [
        "id",
        "LockIdentifier"
      ],
      [
        "amount",
        "Balance"
      ],
      [
        "until",
        "BlockNumber"
      ],
      [
        "reasons",
        "WithdrawReasons"
      ]
    ]
  },
  "VestingSchedule": {
    "type": "struct",
    "type_mapping": [
      [
        "offset",
        "Balance"
      ],
      [
        "perBlock",
        "Balance"
      ],
      [
        "startingBlock",
        "BlockNumber"
      ]
    ]
  },
  "Account": {
    "type": "struct",
    "type_mapping": [
      [
        "nonce",
        "U256"
      ],
      [
        "balance",
        "U256"
      ]
    ]
  },
  "Log": {
    "type": "struct",
    "type_mapping": [
      [
        "address",
        "H160"
      ],
      [
        "topics",
        "Vec<H256>"
      ],
      [
        "data",
        "Bytes"
      ]
    ]
  },
  "Vicinity": {
    "type": "struct",
    "type_mapping": [
      [
        "gasPrice",
        "U256"
      ],
      [
        "origin",
        "H160"
      ]
    ]
  },
  "StorageKind": {
    "type": "enum",
    "value_list": [
      "__UNUSED",
      "PERSISTENT",
      "LOCAL"
    ]
  },
  "OpenTipTo225": {
    "type": "struct",
    "type_mapping": [
      [
        "reason",
        "Hash"
      ],
      [
        "who",
        "AccountId"
      ],
      [
        "finder",
        "Option<OpenTipFinderTo225>"
      ],
      [
        "closes",
        "Option<BlockNumber>"
      ],
      [
        "tips",
        "Vec<OpenTipTip>"
      ]
    ]
  },
  "OpenTipFinderTo225": "(AccountId, Balance)",
  "TreasuryProposal": {
    "type": "struct",
    "type_mapping": [
      [
        "proposer",
        "AccountId"
      ],
      [
        "value",
        "Balance"
      ],
      [
        "beneficiary",
        "AccountId"
      ],
      [
        "bond",
        "Balance"
      ]
    ]
  },
  "BabeAuthorityWeight": "u64",
  "BabeBlockWeight": "u32",
  "equivocationproof<header>": "BabeEquivocationProof",
  "BabeEquivocationProof": {
    "type": "struct",
    "type_mapping": [
      [
        "offender",
        "AuthorityId"
      ],
      [
        "slotNumber",
        "SlotNumber"
      ],
      [
        "firstHeader",
        "Header"
      ],
      [
        "secondHeader",
        "Header"
      ]
    ]
  },
  "BabeWeight": "u64",
  "EpochAuthorship": {
    "type": "struct",
    "type_mapping": [
      [
        "primary",
        "Vec<u64>"
      ],
      [
        "secondary",
        "Vec<u64>"
      ]
    ]
  },
  "RawBabePreDigestTo159": {
    "type": "enum",
    "type_mapping": [
      [
        "Primary",
        "RawBabePreDigestPrimaryTo159"
      ],
      [
        "Secondary",
        "RawBabePreDigestSecondaryTo159"
      ]
    ]
  },
  "RawBabePreDigestPrimaryTo159": {
    "type": "struct",
    "type_mapping": [
      [
        "authorityIndex",
        "u32"
      ],
      [
        "slotNumber",
        "SlotNumber"
      ],
      [
        "weight",
        "BabeBlockWeight"
      ],
      [
        "vrfOutput",
        "VrfOutput"
      ],
      [
        "vrfProof",
        "VrfProof"
      ]
    ]
  },
  "RawBabePreDigestSecondaryTo159": {
    "type": "struct",
    "type_mapping": [
      [
        "authorityIndex",
        "u32"
      ],
      [
        "slotNumber",
        "SlotNumber"
      ],
      [
        "weight",
        "BabeBlockWeight"
      ]
    ]
  },
  "RawBabePreDigestCompat": {
    "type": "enum",
    "type_mapping": [
      [
        "Zero",
        "u32"
      ],
      [
        "One",
        "u32"
      ],
      [
        "Two",
        "u32"
      ],
      [
        "Three",
        "u32"
      ]
    ]
  },
  "VrfOutput": "[u8; 32]",
  "RpcMethods": {
    "type": "struct",
    "type_mapping": [
      [
        "version",
        "u32"
      ],
      [
        "methods",
        "Vec<Text>"
      ]
    ]
  },
  "CreatedBlock": {
    "type": "struct",
    "type_mapping": [
      [
        "hash",
        "BlockHash"
      ],
      [
        "aux",
        "ImportedAux"
      ]
    ]
  },
  "ImportedAux": {
    "type": "struct",
    "type_mapping": [
      [
        "headerOnly",
        "bool"
      ],
      [
        "clearJustificationRequests",
        "bool"
      ],
      [
        "needsJustification",
        "bool"
      ],
      [
        "badJustification",
        "bool"
      ],
      [
        "needsFinalityProof",
        "bool"
      ],
      [
        "isNewBest",
        "bool"
      ]
    ]
  },
  "Conviction": {
    "type": "enum",
    "value_list": [
      "None",
      "Locked1x",
      "Locked2x",
      "Locked3x",
      "Locked4x",
      "Locked5x",
      "Locked6x"
    ]
  },
  "PropIndex": "u32",
  "Proposal": "Call",
  "ReferendumIndex": "u32",
  "ReferendumInfoTo239": {
    "type": "struct",
    "type_mapping": [
      [
        "end",
        "BlockNumber"
      ],
      [
        "proposalHash",
        "Hash"
      ],
      [
        "threshold",
        "VoteThreshold"
      ],
      [
        "delay",
        "BlockNumber"
      ]
    ]
  },
  "ApprovalFlag": "u32",
  "SetIndex": "u32",
  "Vote": "GenericVote",
  "VoteIndex": "u32",
  "VoterInfo": {
    "type": "struct",
    "type_mapping": [
      [
        "lastActive",
        "VoteIndex"
      ],
      [
        "lastWin",
        "VoteIndex"
      ],
      [
        "pot",
        "Balance"
      ],
      [
        "stake",
        "Balance"
      ]
    ]
  },
  "VoteThreshold": {
    "type": "enum",
    "value_list": [
      "Super majority approval",
      "Super majority rejection",
      "Simple majority"
    ]
  },
  "EthereumAddress": "H160",
  "AbridgedCandidateReceipt": {
    "type": "struct",
    "type_mapping": [
      [
        "parachainIndex",
        "ParaId"
      ],
      [
        "relayParent",
        "Hash"
      ],
      [
        "headData",
        "HeadData"
      ],
      [
        "collator",
        "CollatorId"
      ],
      [
        "signature",
        "CollatorSignature"
      ],
      [
        "povBlockHash",
        "Hash"
      ],
      [
        "commitments",
        "CandidateCommitments"
      ]
    ]
  },
  "Bidder": {
    "type": "enum",
    "type_mapping": [
      [
        "New",
        "NewBidder"
      ],
      [
        "Existing",
        "ParaId"
      ]
    ]
  },
  "CandidateCommitments": {
    "type": "struct",
    "type_mapping": [
      [
        "fees",
        "Balance"
      ],
      [
        "upwardMessages",
        "Vec<UpwardMessage>"
      ],
      [
        "erasureRoot",
        "Hash"
      ],
      [
        "newValidationCode",
        "Option<ValidationCode>"
      ],
      [
        "processedDownwardMessages",
        "u32"
      ]
    ]
  },
  "DownwardMessage": {
    "type": "enum",
    "type_mapping": [
      [
        "TransferInto",
        "(AccountId, Balance, Remark)"
      ],
      [
        "Opaque",
        "Vec<u8>"
      ]
    ]
  },
  "GlobalValidationSchedule": {
    "type": "struct",
    "type_mapping": [
      [
        "maxCodeSize",
        "u32"
      ],
      [
        "maxHeadDataSize",
        "u32"
      ],
      [
        "blockNumber",
        "BlockNumber"
      ]
    ]
  },
  "HeadData": "Bytes",
  "LocalValidationData": {
    "type": "struct",
    "type_mapping": [
      [
        "parentHead",
        "HeadData"
      ],
      [
        "balance",
        "Balance"
      ],
      [
        "codeUpgradeAllowed",
        "Option<BlockNumber>"
      ]
    ]
  },
  "ParachainDispatchOrigin": {
    "type": "enum",
    "value_list": [
      "Signed",
      "Parachain",
      "Root"
    ]
  },
  "RelayChainBlockNumber": "BlockNumber",
  "Remark": "[u8; 32]",
  "Retriable": {
    "type": "enum",
    "type_mapping": [
      [
        "Never",
        "Null"
      ],
      [
        "WithRetries",
        "u32"
      ]
    ]
  },
  "Scheduling": {
    "type": "enum",
    "value_list": [
      "Always",
      "Dynamic"
    ]
  },
  "UpwardMessage": {
    "type": "struct",
    "type_mapping": [
      [
        "origin",
        "ParachainDispatchOrigin"
      ],
      [
        "data",
        "Vec<u8>"
      ]
    ]
  },
  "AssetOptions": {
    "type": "struct",
    "type_mapping": [
      [
        "initalIssuance",
        "Compact<Balance>"
      ],
      [
        "permissions",
        "PermissionLatest"
      ]
    ]
  },
  "Owner": {
    "type": "enum",
    "type_mapping": [
      [
        "None",
        "Null"
      ],
      [
        "Address",
        "AccountId"
      ]
    ]
  },
  "PermissionsV1": {
    "type": "struct",
    "type_mapping": [
      [
        "update",
        "Owner"
      ],
      [
        "mint",
        "Owner"
      ],
      [
        "burn",
        "Owner"
      ]
    ]
  },
  "PermissionVersions": {
    "type": "enum",
    "type_mapping": [
      [
        "V1",
        "PermissionsV1"
      ]
    ]
  },
  "PermissionLatest": "PermissionsV1",
  "Approvals": "[bool; 4]",
  "ContractExecResultSuccessTo255": {
    "type": "struct",
    "type_mapping": [
      [
        "status",
        "u8"
      ],
      [
        "data",
        "Raw"
      ]
    ]
  },
  "ContractExecResultTo255": {
    "type": "enum",
    "type_mapping": [
      [
        "Success",
        "ContractExecResultSuccessTo255"
      ],
      [
        "Error",
        "Null"
      ]
    ]
  },
  "AccountStatus": {
    "type": "struct",
    "type_mapping": [
      [
        "validity",
        "AccountValidity"
      ],
      [
        "freeBalance",
        "Balance"
      ],
      [
        "lockedBalance",
        "Balance"
      ],
      [
        "signature",
        "Vec<u8>"
      ],
      [
        "vat",
        "Permill"
      ]
    ]
  },
  "AccountValidity": {
    "type": "enum",
    "value_list": [
      "Invalid",
      "Initiated",
      "Pending",
      "ValidLow",
      "ValidHigh",
      "Completed"
    ]
  }
}

}